Customizing

Everything you can change, from the sea's colour to a boat of your own. Most changes are data: Details panels, data assets, data tables and Project Settings. No code is needed.

The sea#

Sea state, swell and wave forms#

The NA Ocean actor (ANAOcean) holds the sea. Its Preset picks how the sea is made:

Other settings:

• Wave Direction Deg: where the waves travel to (degrees, from +X towards +Y).
• Rogue Waves: the biggest seas send a rogue wave now and then. Call Trigger Rogue Wave for one at a place and time of your choice.
• Confused Sea: hurricane seas get cross swells from the storm's other sides.

From Blueprint:

• Set Preset, Beaufort, Zone or Wave Direction Deg, then call Apply Sea State. The surface and every boat follow at once.
• Get Wave Height returns the surface height at a world position, exactly as the physics sees it.

Shallow water and breakers#

The sea reads the depth under it. Over a shoal the waves slow, steepen and break, and in a sheltered bay they shrink. The depth comes from the map's depth asset, made by the NA Map Setup actor from the ground and the sea floor under its box (see "Maps and start points" below). It does not come from the level's landscape by itself: a map with no depth asset has deep water everywhere. Breaking bars and surf over shallows come out of the depth on their own. Give your coast a gentle slope for long breaking lines.

Colour, clarity and foam#

The look of the water is the ocean's Surface Material, M_NA_Ocean by default. To change it, right-click M_NA_Ocean > Create Material Instance, change the instance's parameters, and set it as the ocean's Surface Material.

The ocean actor sets some parameters itself from the sea state, the wind, the sun and the boats, so a value you put in them is overwritten: change the sea, not those. They are:

• in the group Look: FoamThreshold, FoamSharpness, FoamStreaks, ScatterHeight, ScatterLight, MicroSlope and FarSlope;
• every parameter of the groups Waves, Shore, Breaker and Hull Clip;
• in the group Wakes: ShipWakes, WakeTile0 to WakeTile3, FoamTrail, FoamTrailArea, FoamTrailFar, FoamTrailFarArea, SeaFoam and SeaFoamArea.

Set only the parameters of the table above.

Breakers: the big breaking waves over a shoal or a bar are drawn with their own material, M_NA_Breaker (in the same folder, with the same parameters). A change to the ocean's material does not reach them. The breakers the plugin raises use M_NA_Breaker itself: give it the same values (and keep a note of them, since a plugin update replaces the plugin's folder). A breaker actor placed in your level takes an instance of it in its own Material.

At run time, from Blueprint:

1. Get the level's NA Ocean (for example Get Actor Of Class, class NA Ocean).
2. Call Get Surface Material Instance on it: the sea surface's dynamic material instance. It is None until the surface material has loaded, so check it with Is Valid (try again a moment later if it is not yet).
3. Call Set Vector Parameter Value (for example FoamColor) or Set Scalar Parameter Value (for example FoamAmount) on it, with a parameter name from the table.

The values you set stay: the ocean writes only its own parameters, listed above. Setting another Surface Material on the ocean makes a new instance; set your values again after it.

Under water, the camera's water is M_NA_Underwater (ShallowColor, DeepColor, Extinction, LightFading), set in Project Settings > Plugins > Ocean and Boats Simulator > Underwater Material.

New foam texture: the foam texture (T_NA_FoamPattern) has three independent tiling channels, white being foam:

• R: foam lace, drawn out by the wind;
• G: a sheet of foam holed by cells;
• B: the soft cloud of bubbles under it.

Any tiling texture laid out this way works. Content/Python/OceanTools/make_foam.py makes a new one procedurally. Run it with any Python 3 that has numpy:

python make_foam.py MyFoam.png [--seed 42] [--like T_NA_FoamPattern.png]

--like matches the new pattern's brightness and grain to an existing texture (export one with right-click > Asset Actions > Export). Import the PNG with Compression Settings: Masks and sRGB off, then set it as FoamPattern in your material instance.

The water look sliders#

The pause menu has sliders for the water, made for trying the look out, as in the demo. At sea, Esc > Sea and wind has a Water group:

• Colour: along five kinds of water: deep blue, default (your material's own), turquoise, green and murky;
• Clarity: from murky to clear. The middle is your material's own;
• Foam: from no foam to twice your material's. The middle is your material's own.

A right click on a slider puts it back to its default. The look is kept from map to map until the game quits.

Until you move a slider, nothing is put on the material: your own instance and your own run-time changes stand. Once you move one, the look is put on the sea's material instance over the values of its material: Absorption, Scattering, FoamAmount and WakeFoamAmount.

A game sets its water in the ocean's material instead ("Colour, clarity and foam" above), and switches the sliders off: Project Settings > Plugins > Ocean and Boats Simulator > Interface > Pause Menu Entries > Water Look.

In C++ the look is FNASeaLook (Public/Ocean/NASeaLook.h): FNASeaLook::Get() is the game's look, Set changes it and puts it on a surface material instance, and IsTouched says whether a slider was moved.

New wave presets#

Set the ocean's Preset to Custom and fill its Sea State:

• the wind sea: significant height, peak period, peak enhancement, spreading and direction;
• Swells: any number of them, each with its height, period, direction and spread;
• the depth, for shallow seas.

To keep a sea you like, make a Blueprint child of NA Ocean with that Sea State, or save the ocean actor as a level preset. The included wave forms show realistic values: set one, read its Sea State in the Details panel, and start from there.

Wind#

The wind drives the sea and pushes every boat. The NA Wind world subsystem (UNAWindSubsystem) answers "what is the wind here?". It takes the first of:

1. an override set from Blueprint: Set Wind Override (m/s vector) or Set Wind Override Beaufort (force and direction). Clear Wind Override removes it;
2. wind sources, by priority:
   • any actor or component implementing the NA Wind Source interface (Get Wind At, Get Wind Priority). Level actors are found at play; register others with Register Wind Source;
   • the ready-made NA Wind Source component: a constant wind (speed or Beaufort force, direction) inside an optional radius. Put it on any actor;
   • Ultra Dynamic Weather, when it is in the level (see below);
3. the ocean's own wind, the one its sea was built for, with gusts.

Get Wind, Get Mean Wind and Get Wind Beaufort read it anywhere. Gust strength is a setting.

The sea follows the wind: switch on Sea Follows Wind on the ocean. The sea eases towards the wind's force over Wind Follow Seconds, and builds again when the wind has changed by a whole force or turned past Wind Follow Turn Deg.

Ultra Dynamic Weather / Sky (optional): when they are in the level, the plugin reads Ultra Dynamic Weather's wind and Ultra Dynamic Sky's time of day (for night lights) by reflection. There is no hard link: without them, everything works on its own. The class and property names it looks for are in Project Settings > Plugins > Ocean and Boats Simulator - Wind and Sun, in case a future version renames them.

Night: the included maps are set in daylight, and the plugin has no day and night cycle of its own. With a sky that has one (your own, or Ultra Dynamic Sky), boats light their navigation lights at night: the NA Sun subsystem decides night from the sun's elevation (the directional light marked Atmosphere Sun Light, or Ultra Dynamic Sky's time of day). Set Night Mode to Day or Night to force it.

Your own boat#

What a boat is#

A boat is one data asset, the boat definition (NA Boat Definition). It holds:

• Boat: her meshes and parts. The hull mesh, with sockets where her parts stand; the buoyancy mesh the physics floats; her parts (deck, superstructure, glass, propellers, rudders, outboards, thrusters, trim tabs, radar, wipers, lights, wheel and levers), each turning about its pivot; her option groups and their variants; her paint slots; her physics numbers (mass, top speed, hull kind, deadrise, catamaran).
• Particulars (off by default): her exact numbers (main dimensions, form, mass, centre of gravity, tanks, propulsion). Off, she measures herself from her buoyancy mesh and her Physics numbers.
• Configurations: the versions of her the boat picker offers (engines, propellers, fuel, exhaust, stabilisers, colours, option variants), and the picker's names and descriptions for her option groups.
• Picker: the display name, a short description, the card image, the category, the sort order, Listed and extra stats lines.
• Sound: her engine and horn rows (see "Sounds").

The four included boats are made this way (Content/NavalArchitect/Boats/<Type>/DA_NA_Boat_<Type>). Duplicate one to see how it is set up, but make a new definition for your own meshes: a duplicate keeps Particulars on with the included boat's design numbers, and her parts, option groups and configurations. To use a duplicate anyway, empty Parts and Option Groups (category Boat) and Configs and Groups (category Configurations), and turn Particulars off.

The Seed category's buttons reset a definition to an included boat's numbers. A boat of your own does not need them.

Model it (any 3D package)#

Export all her meshes from one scene, in the hull's space: bow towards +X, deck up (+Z), starboard towards +Y, the centreline at Y = 0.

• Particulars off (the usual case): the origin does not matter. The plugin moves her meshes so that her physics hull's bounds start at X = 0 (aft end) and Z = 0 (keel), centred on Y = 0. A model made facing another way is turned with Mesh Rotation.
• Particulars on: her meshes are used exactly as made and Mesh Rotation is ignored. Model her in her frame: the aft end of her waterline at X = 0, the keel at Z = 0.

The meshes:

• Hull: the outside of the hull, with empties named SOCKET_<name> where parts go. The FBX importer turns them into the static mesh's sockets.
• Buoyancy: a closed, watertight copy of the hull up to the deck edge, a few thousand triangles at most, outward normals. Import it with Nanite off and Allow CPU Access on. Its material slot names mark the regions the physics reads (any case):
  • a name containing Deck, Transom or BowTransom marks that region;
  • a name containing Shell, Hull, Side or Bottom is the shell;
  • any other name is sorted by its facing and height (deck, transom or shell).
• No buoyancy mesh: she floats on the hull mesh's simple collision (its convex hulls and boxes), else on its lowest LOD. The lowest LOD floats in a packaged game only with Allow CPU Access on the hull mesh; the Output Log warns when it is off.
• Parts: one static mesh per moving part. Either exported in the hull's space (Modelled In Place on: it stands where it was made, its socket is only its pivot), or with its origin at its pivot (Modelled In Place off: its origin goes to its socket). The deck, superstructure, glass and fittings are parts too, modelled in place and without a socket.
• Options: parts that belong to an option group's variant (a radar, a hardtop, a fishing tower) are shown only when that variant is picked.

Hull sockets#

A socket's name sets the part's role. Names are read in any case. NAV_..., EYE_Helm and CAM_Bridge are exact names; the others are a prefix followed by any text (PROP_1, PROP_Port), shown here as n. Each part turns about its socket's axes.

Make the definition#

1. Import the meshes (drag the FBX files into the Content Browser).
2. Right-click in the Content Browser > Miscellaneous > Data Asset > NA Boat Definition.
3. Boat > Meshes: set Hull and Buoyancy (and Mesh Rotation if she faces another way).
4. Press Add Parts From Hull Sockets (category Boat): one part for each socket whose name gives its role, with Modelled In Place on, a propeller riding on the outboard or pod nearest it. Set each part's Mesh, turn Modelled In Place off for a mesh whose origin is its pivot, and set its Mass, and for propulsors their Drive (power, diameter, blades). Add the deck, superstructure and glass as parts without a socket (the glass with Role Glass).
5. Physics: her Mass (0: what her hull displaces at two fifths of her depth), Top Speed Knots (engines with a Drive power of 0 are sized for it), Hull Kind, Deadrise, Catamaran, and her Centre Of Gravity if you know it (in the hull mesh's space, cm).
6. Options: option groups and their variants; parts name their Option Group and Variant. A group shows its first variant unless another is picked; the variant Off shows nothing of the group.
7. Configurations: her versions for the picker (see "Configurations" below).
8. Picker: her name, description, card image (16:9), category and sort order. With Listed off she is left out of the picker.
9. Place an NA Boat actor in a level with an NA Ocean, set its Boat Mesh Set to the definition, and press Play: she floats. To take her helm, set World Settings > GameMode Override to NA Sea Trials Game Mode. Select the NA Boat to read what she floats on, her measured numbers and any problem in Boat > Particulars.

Particulars#

Leave Particulars off unless you have her exact numbers.

• Off: she measures herself. Her frame comes from her physics hull's bounds, her draft from her Mass, her form from her hydrostatics, her propulsion from her propulsor parts and their Drive.
• On: Design is used as it is. Mesh Rotation, Physics and each part's Drive are ignored, and her meshes are not moved into her frame. Model her exactly in her frame and fill every number of Design. The included boats use this.

Configurations#

The boat picker reads the definition's Configurations category. (Boat > Options > Configurations is used only by an NA Boat placed without a definition.)

• Configs: her versions, each with a Name and a Description. The first is her as built: leave its Key empty. Every other one has a key of its own.
• A configuration's Variants pair an option group's Name with one of its variants' Name (or Off). A group not named there shows its first variant.
• Hull Colour and House Colour take a swatch key: White, Silver, Navy, Blue, Black, Red, Orange, Yellow, Green or Sand. Empty: her colour as built.
• Stabilisers need Offers Stabilisers on; fin meshes are parts in an option group named Fins (variant On). Exhaust (wet or dry) needs Offers Exhaust on and her EXH_Wet_n and EXH_Dry_n outlets.
• Groups: only the option groups listed here get a row in the picker. Each group's Key must equal the option group's Name, and each variant's Key the variant's Name, the first variant being her as built. Name and Description are what the picker shows. A row left with fewer than two choices is not shown.

Options and versions from a Blueprint#

A Blueprint child of NA Boat can carry a boat's options and versions, with no table to fill in by hand (HowTo.md, guide 5, has the steps):

1. Make the Blueprint (parent NA Boat) and set its Boat Mesh Set, in Class Defaults, category Boat, to the boat definition.
2. Add components to it (static meshes for a crane, a tender...) and give each one Component Tags (Details > Tags).
3. Compile it. The definition sets its Boat Class to the Blueprint by itself (when it is empty), and fills in her option rows and her versions (configurations). The picker shows them, and the shipyard and the sea spawn the boat as your Blueprint.

The tags (names are not case sensitive; = and : both work):

• Versions (category Boat, in the definition) lists the versions in the order you want. The first is the boat as built. Empty, every plain word on the components is a version, from the one with the fewest options fitted to the one with the most; only the words in the list count when it is filled in.
• The button Read Blueprint Options reads the Blueprint again. A compile does it by itself, and so does a change of Boat Class or Versions.
• The rows the Blueprint made are listed in Blueprint Groups and Blueprint Versions, and each reading replaces them. Your own rows stay.
• A piece the picker hides is hidden and has no collision either. A component with no plain word and no Option= tag is always shown.
• Exhaust: a Niagara component tagged Exhaust is shown while the engines run. Its user float parameters EngineLoad (0 to 1), EngineRpm and BoatSpeed (m/s) are set every frame. Place it at the exhaust outlet. The plugin ships no smoke effect: use a Niagara system of your own. Get Exhaust Outlet Locations gives the outlets of her parts, relative to the boat actor.
• Keep the Blueprint in the same folder as her definition and meshes (see "In the boat picker and in a packaged game").

Propulsion#

• Each propulsor part is one unit: a PROP_n riding on nothing is a shaft, an outboard or a pod carries the propeller riding on it, a THRUSTER_n is a tunnel thruster.
• A PROP_n part with no RUDDER_n part within 15% of her length has no rudder: the wheel cannot steer through it.
• An outboard or a pod with no propeller riding on it takes its propeller diameter from its own mesh's size: set its Drive > Diameter.
• With no propulsor parts at all she still moves, on an invisible twin screw laid out on her hull, and the Output Log says which units have no part.
• A Drive > Power of 0 is the unit's share of what her Top Speed Knots needs.

Lights, windows, wipers and radar#

• Lenses glow with their lights on material slots whose names contain NavRed, NavGreen, NavWhite or SearchLens; slots named Courtesy or Underwater glow with the deck lights (the lights' All step, which is offered only on a boat that has FLOOD_n sockets or such slots).
• Lit windows at night need a part with Role Glass.
• Wipers start parked; U cycles them off, slow and fast (or set the NA Boat's Wiper Rate).
• The helm display's radar page needs a shown RADAR_n part with a mesh, or a picked variant of an option group named Radar with a mesh (a dome that does not turn).
• Her wet topsides and the white water along her hull show only when her Paint Slot material is M_NA_Boat_Paint or an instance of it.

Paint and materials#

• The hull's paint slot (Paint Slot, Topsides by default) is tinted through the material's Tint parameter: configurations and the player pick the colour. House Paint Slot does the same for the superstructure.
• The included boats' materials are instances of three masters in Content/NavalArchitect/Boats/Materials: M_NA_Boat_Surface (tiling textures, wear and grime), M_NA_Boat_Paint (the same with a clear coat, wet topsides and hull white water) and M_NA_Boat_Glass (windows and lenses, with the glow the lights drive).
• The shared tiling texture sets are T_NA_Surf_<Set>_BaseColor, T_NA_Surf_<Set>_Normal and T_NA_Surf_<Set>_ORM in Content/NavalArchitect/Boats/Materials/Textures (ORM: R occlusion, G roughness, B metallic). They tile on UV0 in metres (Tiling is repeats per metre), so unwrap UV0 at real size.
• Make instances of the masters for your boat, with these textures or your own laid out the same way. Tint and TintAmount colour a surface.

In the boat picker and in a packaged game#

• The boat picker is in the shipyard: open L_NA_Start (in NavalArchitect/Maps) and press Play, or press B twice at sea. It lists every definition in the project that can sail, by Sort Order, then by name.
• A definition that cannot sail (no hull mesh, nothing to float) is left out, with the reason in the Output Log on a line tagged [NABOAT].
• Project Settings > Plugins > Ocean and Boats Simulator > Boats names definitions for the picker. With Find All Boats on (the default) every definition in the project is listed anyway; turn it off to list only those.
• Packaging: the plugin cooks its own folders only. Put your boat in a map you package (an NA Boat with her as Boat Mesh Set), or add her folder to Project Settings > Packaging > Additional Asset Directories to Cook. Keep her meshes, materials and textures in that folder, and her Blueprint too if she has one.

Minimum steps#

1. Import her hull and a buoyancy mesh (bow +X, deck up). On the buoyancy mesh: Nanite off, Allow CPU Access on.
2. Right-click in the Content Browser > Miscellaneous > Data Asset > NA Boat Definition. Set Boat > Meshes > Hull and Buoyancy, and leave Particulars off.
3. Physics: set Top Speed Knots, and her Mass if you know it.
4. Optional: press Add Parts From Hull Sockets and set each part's Mesh (Modelled In Place off for a mesh whose origin is its pivot).
5. In a level with an NA Ocean, place an NA Boat near the surface, set its Boat Mesh Set to the definition, and set World Settings > GameMode Override to NA Sea Trials Game Mode.
6. Press Play. If she floats wrong, read the NA Boat's Boat > Particulars and the Output Log's [NABOAT] lines.

Maps and start points#

The maps the player can sail in are the rows of one data table, the places table: Project Settings > Plugins > Ocean and Boats Simulator > Shipyard > Places Table. By default it is DT_NA_Places (in Content/NavalArchitect/Maps), with 3 rows: NA_Map_Demo, NA_Map_OpenOcean and NA_Map_WaveTank. Duplicate it into your own folder and set Places Table to your copy, since a plugin update replaces the plugin's folder.

• A row is of the row structure NA Start Point, one row for a map: Name, Region, Description, Picture, Kilometres, Heading, Beaufort, Waves From, Swell Height, Swell Period, Spots, Map, Depth, Sky Place and Wave Tank. HowTo.md, guide 12, says what each one holds.
• The scenario screen lists every row, with its picture, its chart and its spots.
• To remove a map from the game, delete its row. Also switch off its start screen entry (Interface > Start Menu Entries), or clear Open Ocean Map or Wave Tank Map under Interface > Maps.
• To add a map, the easy way is two editor-only actors. NA Map Setup holds the place's name and words, the sea, and a box over the water to chart. NA Start Spot marks where boats may start (set Spot Name, Kind, Description and Order; its rotation is the heading). Open the map with all of it loaded, place them, and press Make Place in NA Map Setup's Details panel. It traces the ground and the sea floor under the box (everything static that has collision), saves DA_<Map>_Depth next to the map, and writes or updates the map's row in the table (its Row Name is the map's name by default). The Result field says what it did. Neither actor is in a packaged game.
• The depth asset drives the chart, the echo sounder, the radar, and the waves steepening and breaking over shallows. Without it the sea is deep everywhere.

The interface#

Skins#

The interface draws its panels from a theme (NA UI Theme): colours, fonts, panel shapes, icons and UI sounds. It covers the start screen and the menus, the loading screen, the pause menu, the helm display and the other windows at sea.

• Three themes are included in Content/NavalArchitect/UI/Themes: DA_NA_Theme_Day, DA_NA_Theme_Night and DA_NA_Theme_HighContrast.
• Pick one in Project Settings > Plugins > Ocean and Boats Simulator > Interface > Theme. Empty: the built-in Day theme.
• For your own: duplicate a theme data asset into your own folders, change it, and select it.

The boat picker does not use that theme. It has its own (NA Configurator Theme): its day and night palettes, its fonts, a sound for each kind of button, pictures in place of its line icons, and texts in place of its cards' own.

• Pick it in Project Settings > Plugins > Ocean and Boats Simulator - Boat Picker > Look > Theme. Empty: the picker's own look. Night By Default opens the picker in its night lighting.
• No picker theme asset is included. To make one: right-click in the Content Browser > Miscellaneous > Data Asset > NA Configurator Theme, change it, and select it.

Turning parts off#

Project Settings > Plugins > Ocean and Boats Simulator > Interface switches each part on or off:

• Show Start Screen: the start screen and its menu (off: the start map opens the demo map at once);
• Show Boat Picker: the boat picker before sailing (off: Sail on the start screen goes straight to the demo map);
• Show Helm Display, and Helm Display Pages: the helm display, and each of its pages and windows (Helm, Gauges, Chart, Radar, Sonar, Engines, Roll, Switches, Autopilot Window, Info Window);
• Show Wave Tank Panel: the wave tank's panel;
• Show Help: the on-screen help (the F1 key list and the line of keys at the top of the screen);
• Show Loading Screen: the loading screen between maps;
• Show Pause Menu: the pause menu (Esc) at sea;
• Start Menu Entries: the start screen's entries Sail, Open Ocean, Wave Tank, Settings, Controls and Quit. With Quit off, Esc on the start screen no longer asks to quit;
• Pause Menu Entries: the pause menu's entries Settings, Controls, Sea And Wind, Water Look (the water's sliders, see "The water look sliders"), Shipyard, Restart, Right Her and Main Menu.

A start screen entry whose map is not set is hidden. Open Ocean uses Open Ocean Map and Wave Tank uses Wave Tank Map (both under Interface > Maps). Sail uses Shipyard Map (under Shipyard), or Demo Map (under Interface > Maps) when Show Boat Picker is off or there is no Shipyard Map. An entry whose map is set but is not in the project shows locked.

Use only the parts your game needs. The physics never depends on the interface.

Loading screens#

With Show Loading Screen on, the loading screen between maps shows a picture, a title and a line:

• Loading Pictures: pictures of your own. One is picked at random for each load.
• Loading Screens: a screen of its own for a map. Each element has a Map, a Picture, a Title (shown in capitals) and a Subtitle (the line under it; it shows with a Title).
• The picture is chosen in this order: the map's own entry in Loading Screens, then a random one of Loading Pictures, then the theme's Loading picture (the Pictures map of the NA UI Theme).
• Use 16:9 pictures, 1920 x 1080 or larger.

Both lists are in Project Settings > Plugins > Ocean and Boats Simulator > Interface. Loading Tips (one for each load) are there too.

Sounds#

Every sound the plugin plays is a row of one data table, the sound table: DT_NA_Sounds in Content > NavalArchitect > Audio by default, set in Project Settings > Plugins > Ocean and Boats Simulator > Sounds > Sound Table. The row name is the event. Each row (an NA Sound Row) holds:

A loop's input is what the simulation feeds it, from 0 to 1: the engine revolutions, the speed, the sea state. A one-shot's input is how hard it is (a slam), and one-shots without one (the interface, the horn, the bells) play at a random point between Min and Max, so repeats never sound identical.

The rows#

Each boat picks her own engine and horn rows, in her boat definition (category Sound):

• Engine Sound Rows is the prefix of her engine rows: Engine_Inboard plays Engine_Inboard_Idle and Engine_Inboard_Load. Add rows of your own (for example Engine_Jet_Idle and Engine_Jet_Load) and set the prefix to Engine_Jet. Empty: picked from her machinery as in the table above.
• Horn Sound Row names the row her horn plays. Empty: Horn.

Her Sound component (NA Ship Sound Component) can override both for one boat in a level (Engine Row Prefix, Horn Row). Its Rain Rate drives the rain rows, and its Volume scales all her sounds.

The start screen's music is not a row: set Project Settings > Plugins > Ocean and Boats Simulator > Interface > Start Music (empty by default).

Replacing sounds#

• One sound: open the table and change the row's Sound, volume or pitch. No code, no restart.
• Your own set: duplicate DT_NA_Sounds into your project's folders, change its rows, and pick it in Sound Table. Keep your sounds out of the plugin's folder: a plugin update replaces it.
• From Blueprint, with any row, the plugin's or your own: Play Sound 2D Row, Play Sound at Location Row, Spawn Sound Attached Row and Spawn Sound 2D Row (they return the component, for loops), Set Row Input (a playing loop to a row's volume and pitch at an input), Find Sound Row, Play UI Sound (category Ocean and Boats > Sound).
• A missing row or sound is silent, with one [NASOUND] warning in the Output Log.

A ready-made set of 49 sounds is included, one for every row; replace any row with your own. The set's generator is Content/Python/na_synth_sounds.py (any Python 3); it writes SW_NA_<Row>.wav files to <project>/Saved/Audio/Synth.

Importing a folder of sounds#

Content/Python/na_import_sounds.py (editor Python: Edit > Plugins > Python Editor Script Plugin on) imports a folder of SW_NA_<Row>.wav, .mp3, .ogg or .flac files as sound waves, looping where the event loops, and creates or updates a sound table with a row for each. In Window > Output Log, with its input set to Python:

py "<plugin>/Content/Python/na_import_sounds.py" --source "D:/MySounds" --dest /Game/Audio/OceanBoats

This makes /Game/Audio/OceanBoats/DT_NA_Sounds; pick it in Sound Table. Run it again after changing the files: rows keep the volumes, pitches, attenuation and descriptions you set (--reset restores the defaults). Options: --table <path>, --rows A,B, --dry-run. It lists the events that still have no sound.

Languages#

All player-facing text is localizable (FText). English, Italian, German, French, Spanish, Polish and Brazilian Portuguese are included, in the plugin's localization target NavalArchitect (Content/Localization/NavalArchitect), which loads with the plugin. The game shows the language of the player's system, or the one your game sets.

A packaged game holds only the languages its packaging settings stage (QuickStart, "Packaging your game").

To change a translation or add a language, edit or add the culture's NavalArchitect.po file (any PO editor) and compile it to its .locres with the engine's GatherText commandlet. The plugin's Config/Localization folder holds the gather, import and compile settings, with the plugin in your project's Plugins folder:

UnrealEditor-Cmd.exe <YourProject>.uproject -run=GatherText -config="Plugins/NavalArchitect/Config/Localization/NavalArchitect_Compile.ini" -unattended

Run NavalArchitect_Import.ini first to read edited .po files, and NavalArchitect_Gather.ini and NavalArchitect_Export.ini after changing the plugin's source text. To add a language, add it to CulturesToGenerate in those files.

The Language setting in the menus offers a fixed list, in C++ (FNALanguage::Cultures in Source/NavalArchitect/Private/Front/NAMenu.cpp): add a new language's culture code there and rebuild to offer it there. Without that, the game still shows it when it is the player's system language.

Controls#

The sea trials pawn (NA Sea Trials Pawn) makes its Enhanced Input actions and mapping contexts when it starts (ANASeaTrialsPawn::MakeInput in Source/NavalArchitect/Private/Trials/NASeaTrials.cpp). The helm's keys and the gamepad work in every camera; W A S D drive in the chase and bridge cameras and fly in the free camera. The keys are listed in QuickStart and in the game with F1.

• To change a key, change its Map(...) line in MakeInput and rebuild.
• For controls of your own (your own pawn and mapping context, a steering wheel, touch), call the helm functions of the boat's NA Ship Motion component: they are what the keys call (Helm Levers, Helm Wheel, Helm Set Wheel, Helm Thrusters, Helm Tabs, Helm All Stop, Helm Autopilot; see BlueprintAPI, "Helm").
• To let a character of your own take the helm, call Take Helm on NA Sea Trials Pawn; Leave Helm gives the character back (BlueprintAPI, "Taking the helm"; HowTo.md, guide 13).