How to

Step-by-step guides, one task each. Follow the steps in order. Each guide ends with a check, and with what to look at when the check fails. QuickStart.md covers installing the plugin; Customizing.md and BlueprintAPI.md hold the details.

Before you start: in the Content Browser, click Settings (gear) and enable Show Plugin Content. The plugin's content is in Plugins > Ocean and Boats Simulator Content > NavalArchitect.

Keep your own assets (material instances, sound tables, places tables, Blueprints, themes) in your project's folders, not in the plugin's: a plugin update replaces the plugin's folder.

1. Put the ocean and a boat in your own level and sail#

1. Open your level. Delete any other water body or ocean plane in the area: the plugin draws its own sea.
2. Open Window > Place Actors, type NA Ocean in its search box and drag NA Ocean into the viewport.
3. In the ocean's Details panel, set Location Z to 0. The sea level is always world Z = 0 (the ocean puts itself back there if you move it up or down). X and Y do not matter: the sea follows the camera.
4. Make sure the level has a sky: a Directional Light (with Atmosphere Sun Light on), a Sky Atmosphere and a Sky Light. Add them from Place Actors if they are missing.
5. In Place Actors, type NA Boat and drag NA Boat into the viewport. Put her on the water: Location Z about 0.
6. In the boat's Details panel, category Boat, set Boat Mesh Set to a boat definition, for example DA_NA_Boat_CentreConsole (in NavalArchitect > Boats > CentreConsole). The boat appears in the viewport.
7. Open Window > World Settings. Under Game Mode, set GameMode Override to NA Sea Trials Game Mode.
8. Press Play.

A level of your own has no depth data, so its sea is deep everywhere. To give your coast shallows that make the waves steepen and break, add the map to the places table (guide 12).

Check it works: she floats at her waterline, the helm display shows, and W (or the Up arrow) pushes her throttle ahead. F1 lists the keys.

If it does not:

• She sinks or jumps out of the water: select the NA Boat and read Boat > Particulars (what she floats on and what to fix), and the Output Log's lines tagged [NABOAT] (Window > Output Log).
• No helm display, and the keys do nothing: check step 7. Also check Project Settings > Plugins > Ocean and Boats Simulator > Interface > Show Helm Display.
• W A S D do nothing: you are in the free camera, where they fly the camera. Press V for the chase camera; the arrows drive in every camera.
• The sea is flat: select the NA Ocean and check Preset and Beaufort (guide 3).

2. Change the sea's colour, clarity and foam#

In the editor:

1. In the Content Browser, open NavalArchitect > Materials. Right-click M_NA_Ocean > Create Material Instance, and move the new instance into your own folder.
2. Open the instance. Tick a parameter to change it. The useful ones: The full list is in Customizing.md, "Colour, clarity and foam". Leave the other parameters alone: the ocean sets them itself.
   • group Water: Absorption (lower values make clearer water), Scattering (the water's own colour; raise the green for a greener sea);
   • group Look: FoamColor, FoamAmount, ScatterColor, Roughness;
   • group Wakes: WakeFoamAmount.
3. Select the NA Ocean in the level. In its Details panel, category Ocean, set Surface Material to your instance.

At run time, from Blueprint (for example in the Level Blueprint):

1. From Event BeginPlay, add Get Actor Of Class with Actor Class = NA Ocean.
2. From its return value, call Get Surface Material Instance.
3. Add Is Valid on the instance. On Is Valid, call Set Vector Parameter Value (Parameter Name FoamColor, your colour) or Set Scalar Parameter Value (Parameter Name FoamAmount, for example 0.5) on it.
4. On Is Not Valid, add a Delay of 0.2 s and try steps 2 and 3 again: the instance exists only once the surface material has loaded.

The pause menu has sliders for the water too, made for trying the look out, as in the demo. At sea, press Esc and open Sea and wind: its Water group has Colour (deep blue, default, turquoise, green, murky), Clarity and Foam. A right click on a slider puts it back to its default. The sliders are kept until the game quits. Once you move one, it sets Absorption, Scattering, FoamAmount and WakeFoamAmount of the sea over the values of your material instance; untouched, they leave the material as it is. A game sets its water in the material instance (above) and switches the sliders off: Project Settings > Plugins > Ocean and Boats Simulator > Interface > Pause Menu Entries > Water Look (guide 11).

Check it works: in the editor the water in the viewport changes as you change the instance; at run time the change shows when your Blueprint runs, and it stays.

If it does not:

• Nothing changes: the ocean's Surface Material is not your instance (editor), or the parameter name is misspelled (run time: the names are exactly as in the material, without spaces).
• A change comes back by itself: you set one of the parameters the ocean sets itself (FoamThreshold, FoamSharpness, FoamStreaks, ScatterHeight, ScatterLight, MicroSlope, FarSlope, or the groups Waves, Shore, Breaker and Hull Clip).
• The big breakers keep their old colour: they use their own material, M_NA_Breaker (Customizing.md).

3. Change the sea state, the wind and the wave direction#

In the editor, select the NA Ocean. In its Details panel, category Ocean:

1. Preset: Beaufort (a wind sea), Zone (a sea area), one of the five wave forms (Long ocean swell, Cross sea, Giant shoal waves, Distant hurricane swell, Breaking bar) or Custom (the Sea State exactly as set).
2. Beaufort: 0 (flat calm) to 12 (hurricane); 13 and 14 for seas past the scale. It is used by the Beaufort and Zone presets.
3. Zone: the sea area, with the Zone preset.
4. Wave Direction Deg: where the waves run to, in degrees from +X towards +Y.
5. Optional: Rogue Waves (on by default) and Confused Sea.

The surface in the viewport changes as you set them. The Apply Sea State button in the Details panel rebuilds the sea by hand.

From Blueprint:

1. Get the NA Ocean (Get Actor Of Class, class NA Ocean).
2. Set its Preset, Beaufort and Wave Direction Deg (or Zone).
3. Call Apply Sea State on it. The surface and every boat follow at once.

The wind: by default each boat feels the ocean's own wind, the one its sea is made for. To give the level a wind of its own and make the sea follow it:

1. On the NA Ocean, category Ocean > Wind, turn on Sea Follows Wind. Set Wind Follow Seconds (how slowly the sea takes up a change of wind) and Wind Follow Turn Deg (how far the wind turns before the waves turn with it).
2. Give a wind, one of:
   • add an NA Wind Source component to any actor in the level and set its Wind Speed (m/s) or Use Beaufort and Beaufort, and its Toward Deg;
   • from Blueprint: get the NA Wind Subsystem and call Set Wind Override Beaufort (Beaufort, Toward Deg), or Set Wind Override (a velocity in m/s). Clear Wind Override removes it;
   • Ultra Dynamic Weather in the level: its wind is read by itself.
3. Keep the ocean's Preset on Beaufort or Zone: the sea follows the wind only with those.

Check it works: press Play. The sea is as you set it; with Sea Follows Wind on, it builds or falls towards the new wind over Wind Follow Seconds. Page Up and Page Down change the sea at the helm too.

If it does not:

• The Blueprint change does nothing: call Apply Sea State after setting the properties.
• Beaufort does nothing: the Preset is a wave form or Custom, which ignore it.
• The sea does not follow the wind: Sea Follows Wind is off, the Preset is not Beaufort or Zone, or there is no wind source (a wind source component, a wind override or Ultra Dynamic Weather). It acts only in play.

4. Add your own boat#

The short version of Customizing.md, "Your own boat" (read it for the details: sockets, parts, propulsion, paint):

1. Model her bow towards +X, deck up (+Z), starboard towards +Y. Export her hull, and a closed buoyancy copy of it up to the deck edge (a few thousand triangles).
2. Import both. On the buoyancy mesh: Nanite off, Allow CPU Access on.
3. Right-click in the Content Browser > Miscellaneous > Data Asset > NA Boat Definition.
4. In it, set Boat > Meshes > Hull and Buoyancy. Leave Particulars off.
5. Physics: set Top Speed Knots, and her Mass if you know it.
6. Optional: press Add Parts From Hull Sockets (category Boat) and set each part's Mesh.
7. Picker: set her Display Name, Description and Card Image.
8. Place her in a level as in guide 1 (Boat Mesh Set = your definition).

Check it works: she floats level at a sensible waterline, and she is listed in the boat picker (open L_NA_Start and press Play).

If it does not: read the NA Boat's Boat > Particulars and the Output Log's [NABOAT] lines. A definition with Listed off, or one that cannot sail (no hull mesh, nothing to float), is left out of the picker.

5. Add an option to a boat (a crane, a tender, a hardtop)#

An option is something she may carry or not (a crane, a tender, a hardtop), or something that comes in several variants, one shown at a time. The boat picker offers each option as a row of cards. A version is the boat sold with some options fitted (Standard, Pro, Max); the picker offers the versions as her configurations.

There are two ways. The first, from a Blueprint, is the easy one: you tag components and the plugin makes the tables for you. The second fills in the tables of the boat definition by hand.

The first way: from a Blueprint The example sells one boat in three versions: Standard (no extras), Pro (a small crane) and Max (a large crane and a tender).

1. Make your boat definition (guide 4), or duplicate a shipped one. A duplicate keeps the shipped boat's own option rows; the ones you make are added to them.
2. Right-click in the Content Browser > Blueprint Class > All Classes, search NA Boat, select it and name the Blueprint (for example BP_MyBoat).
3. Open it. In Class Defaults, category Boat, set Boat Mesh Set to your definition.
4. In the Components panel, select BoatModel (Boat Model), then + Add > Static Mesh. Add one for each piece: here CraneSmall, CraneLarge and Tender. Set each one's Static Mesh, and place it as in guide 6, step 4.
5. Give each piece its tags. Select the component, and in the Details panel open Tags > Component Tags. Click + for each tag and type it. The tags of the example:
   • CraneSmall: Pro, Option=Crane, Variant=Small, Mass=250;
   • CraneLarge: Max, Option=Crane, Variant=Large, Mass=350;
   • Tender: Max, Mass=200.
6. Open your boat definition. In category Boat, find Versions and add three elements, in this order: Standard, Pro, Max.
7. Go back to the Blueprint and press Compile. The definition sets its Boat Class to your Blueprint by itself, 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. Save the Blueprint and the definition (File > Save All).

What the tags mean (names are not case sensitive; = and : both work):

• A plain word names a version the piece is fitted in (Standard, Pro, Max...). A piece with a plain word is an option piece.
• Option=Crane groups pieces into one option (here the two cranes). Without it, the component's name is the option (the tender's option is Tender).
• Variant=Large makes the piece one of several variants of its option. One variant is shown at a time. Without it, the option is simply fitted or not.
• Mass=350 is the piece's mass in kg. It counts only while the piece is shown.
• Icon=Purpose.Workboat is the key of the configurator icon on the option's cards.
• Exhaust goes on a Niagara component (guide 6).

What the example gives: three versions, Standard (the boat as built), Pro and Max, and two rows, Crane (None, Small, Large) and Tender (None, Fitted). Picking a version fits its pieces: Pro the small crane, Max the large crane and the tender. The player can then change each option on its own.

More to know:

• Versions fixes the versions and their order. The first is the boat as built. Leave it empty and every plain word on your components becomes a version, from the one with the fewest options fitted to the one with the most. A stray word then makes a version you did not mean, so fill Versions in: only the words it lists count.
• The button Read Blueprint Options (category Boat, in the definition) 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 (the versions after the first). Each reading replaces them, so do not edit them. Your own rows (the second way) stay.
• A piece the picker hides is hidden and has no collision either. A component with no plain word and no Option= tag is not an option: it is always shown.

Check it works: in the definition, Blueprint Groups lists Crane and Tender. Open L_NA_Start, press Play and pick her: the picker shows the three versions and the Crane and Tender rows, and picking Large shows the large crane. On a boat in your own level, call Set Variant (Group Crane, Variant Large, Fix on) or Set Configuration (Max) on the NA Boat.

If it does not:

• Blueprint Groups is empty: the definition has no Boat Class, or none of your components has a plain word or an Option= tag. Check that the Blueprint's Boat Mesh Set is this definition and compile again, or press Read Blueprint Options. If Boat Class names another Blueprint, the compile leaves it alone: set it to yours.
• A piece is always shown: it has no plain word and no Option= tag, or a tag is misspelled, or its word is not in Versions.
• A version you did not mean is listed: Versions is empty. Fill it in.
• A row is missing: a row needs at least two choices.
• At sea she is a plain NA Boat: Boat Class is empty (compile again) or names another class.

The second way: with the definition's tables Use it for pieces that are the definition's own parts (a mesh at a hull socket), with no Blueprint. It takes two tables in the boat definition, and both are required: the boat's own (Boat > Options: what she shows and weighs) and the picker's (Configurations: what the player reads). The example adds a crane, off by default.

The names must match exactly everywhere: the group Crane, the variants Off and Large.

In the boat definition:

1. Boat > Options > Option Groups: add an element. Name: Crane.
2. In its Variants, add two elements, in this order:
   • element 0: Name Off (the first variant is her as built: no crane);
   • element 1: Name Large; Mass: the crane's mass in kg; Centre: where that mass stands, in the hull mesh's space (cm; zero: at the crane mesh's centre).
3. Boat > Parts: add an element. Name: Crane; Mesh: the crane's static mesh; Option Group: Crane; Variant: Large. Place it with a Socket, or turn on Modelled In Place for a mesh exported in the hull's space. Give its weight in one place only: the part's Mass or the variant's Mass.
4. Configurations > Configurations > Groups: add an element. Key: Crane; Name: the row's title (for example "Crane"); Description: one sentence for the row's tooltip; Icon: a picture key for its cards (for example Purpose.Workboat).
5. In that group's Variants, add two elements, in the same order as in step 2:
   • element 0: Key Off; Name (for example "None"); Description (for example "No crane.");
   • element 1: Key Large; Name (for example "Large crane"); Description (one sentence).
6. Optional: if a variant needs another group's variant (an arch only with the open top), add it to that variant's Requires (group to variant) in both tables: step 2's variant and step 5's variant.
7. Optional: to make a configuration that carries the crane, open Configurations > Configurations > Configs and, in one configuration's Variants, add Crane to Large.
8. Save the definition.

Each time you edit the definition, the Output Log (Window > Output Log) lists what is wrong with its configurations and option groups, on lines tagged [NABOAT].

Check it works: the Output Log shows no [NABOAT] line about the crane. Open L_NA_Start, press Play and pick her: the boat picker shows a Crane row with two cards, and picking Large crane shows the crane on her. On a boat in your own level, call Set Variant (Group Crane, Variant Large, Fix on) on the NA Boat, or Set Configuration with a configuration from step 7.

If it does not:

• The row is missing: a row needs at least two choices. Check that both variants are in both tables (steps 2 and 5), that the group's Key equals the option group's Name, and that every group and variant of steps 4 and 5 has a Name and a Description.
• A card says "Not on this boat": that variant is in the picker's table (step 5) but not in Boat > Options > Option Groups (step 2).
• The card is there but no crane shows: the part's Option Group and Variant (step 3) do not match, or its Mesh is empty.
• A card says "Comes with ...": that variant requires another one (step 6), which is picked with it.

6. Add smoke, a particle effect, a flag or an extra light to a boat#

Lights first: a light that stands at a NAV_, FLOOD_ or SEARCH_ socket of her hull mesh works with no Blueprint. Press Add Parts From Hull Sockets in her definition (or add a part with Role Light, its Light Kind and its Socket). Navigation lights light by themselves at night and with N; floodlights come on with the lights' All step (N); searchlights with Y. A flag that does not move is a part too (a mesh at a socket). For anything else (smoke, sparks, a waving flag, a light of your own), use a Blueprint:

1. In the Content Browser, right-click > Blueprint Class > All Classes, search NA Boat, select it and name the Blueprint (for example BP_MyBoat).
2. Open it. In Class Defaults, category Boat, set Boat Mesh Set to her definition.
3. In the Components panel, select BoatModel (Boat Model), then + Add > Niagara Particle System (or the component you need). It is added under Boat Model. Set its Niagara System Asset.
4. Place it: the hull mesh is made only when the boat is built, so its sockets cannot be picked in the Blueprint editor. Open her hull static mesh, open Window > Socket Manager, select the socket you want and copy its Relative Location (and Relative Rotation) into the new component's Location (and Rotation). Under Boat Model, those values land exactly on the socket.
5. Compile and save.
6. Open her boat definition. In category Boat, check that Boat Class is your Blueprint: the compile sets it by itself when it is empty. If it names another class, set it to your Blueprint.
7. In your own levels, place your Blueprint in place of a plain NA Boat.

Smoke from her exhaust, with no graph: tag the Niagara component Exhaust.

1. Make the Blueprint and add a Niagara Particle System under BoatModel (steps 1 to 4 above). Set its Niagara System Asset to a smoke system of your own: the plugin ships no smoke effect.
2. Place it at the exhaust outlet.
3. In its Details panel, open Tags > Component Tags, click + and type Exhaust.
4. In your Niagara system, add User parameters of type float named EngineLoad, EngineRpm and BoatSpeed, and use the ones you need (for example the spawn rate from EngineLoad).
5. Compile and save.

The component is shown while her engines run and stops when they stop. Every frame the plugin sets EngineLoad (0 to 1), EngineRpm (revolutions per minute) and BoatSpeed (m/s). With several engines they are the highest values. A component tagged Exhaust can carry a version or option tag as well (guide 5): it then shows only where that piece is fitted.

To drive an effect of your own from Blueprint, in the Blueprint's Event Graph, on Event Tick:

• from the Motion component, read Engine Revolutions (-1 to 1), Throttle (-1 to 1) or Speed Knots, or call Get Engine Count, Get Engine Load (Engine; 0 to 1) and Get Engine Rpm (Engine);
• pass the value to your effect, for example Set Niagara Variable (Float) on the Niagara component with the name of a User parameter of your system.

To put smoke at every exhaust outlet, wherever her configuration puts them:

1. Call Get Exhaust Outlet Locations on the boat (self). It returns the outlets shown now, in her frame: cm, relative to the actor.
2. For each location, Spawn System Attached (Attach to Component: Boat Root; Location: the location; Location Type: Keep Relative Offset). Keep the returned components in an array.
3. Do this once on Event BeginPlay (she is built before it). Then, still on BeginPlay, Bind Event to On Boat Rebuilt (target self) with a custom event that destroys the old components and does step 2 again. On Boat Rebuilt fires after a definition, configuration or option change, so your effects follow her new parts.

For a waving flag, Get Wind (World Location) on the NA Wind Subsystem gives the wind there in m/s.

Check it works: press Play in a level with your Blueprint, or launch her from the shipyard (L_NA_Start): at sea she is spawned as your Blueprint, and your effect shows at the socket and follows the engines.

If it does not:

• The effect is in the wrong place: it is not under BoatModel, or the socket's location was not copied exactly. For the exhaust locations, attach to Boat Root, not Boat Model: they are relative to the actor.
• She is a plain NA Boat at sea: the definition's Boat Class is empty or names another class, or the level already has an NA Boat of its own (the sea trials then sail that one). The Output Log says on a [NABOAT] line when the Boat Class did not load.
• The effect does not react: check that the Tick reads the boat's own Motion component, that the engine index is below Get Engine Count, and that the name you set matches the Niagara system's User parameter.
• The tagged smoke never shows: the tag is not exactly Exhaust, the component is not a Niagara one, or her engines are stopped.

7. Several boats in one level#

1. Place more NA Boat actors (guide 1, steps 5 and 6), each with its Boat Mesh Set, apart from one another.
2. The sea trials pawn takes the helm of the first NA Boat it finds; the others float at rest. The helm display, the cameras and the keys follow the boat it drives.
3. To move the others from Blueprint: on each one's Motion component, turn on Helm (category Motion > Helm) and call the helm functions (Helm Levers, Helm Set Wheel...; Recipes.md), or leave Helm off and set Throttle and Rudder Angle directly. Start Underway (Knots) puts one under way at once.

Performance: each fully simulated boat costs several milliseconds of game thread time; measured, about 6 to 8 ms for each extra boat on a desktop PC with a development build. The plugin is designed around one player boat with full physics, plus one or two more. The ocean draws the wakes of the four boats nearest the camera.

To make an extra boat cheaper, select it, select its Motion component, and before Play:

1. category Motion > Wake: turn off Wake and Near Wake (she leaves no wake and raises no waves for the others);
2. category Motion > Spray: turn off Spray;
3. category Motion: raise Max Substep from 1/120 s to 1/60 s (type 0.016667).

Check it works: press Play and type stat unit and stat game in the console: the Game time falls as you make the extra boats cheaper.

If it does not:

• The pawn drives the wrong boat: it takes the first one it finds. Keep one NA Boat for the player, drive the player's boat from your own pawn, or send the pawn to another boat with Set Ship or Take Helm (guide 13).
• A boat does not answer the helm functions: turn on its Helm (step 3).
• The game is still slow: count the boats with Wake and Spray on, and measure in a packaged build, which runs faster than Play In Editor.

8. Change the interface's look, and the boat picker's#

The interface (the start screen and the menus, the loading screen, the pause menu, the helm display) and the boat picker have a theme each.

The interface:

1. In the Content Browser, open NavalArchitect > UI > Themes. Duplicate DA_NA_Theme_Day, DA_NA_Theme_Night or DA_NA_Theme_HighContrast into your own folder.
2. Open the copy (an NA UI Theme) and change its Colours, Helm Display colours, Fonts and Shape.
3. In Project Settings > Plugins > Ocean and Boats Simulator > Interface, set Theme to your copy.

The boat picker:

1. Right-click in the Content Browser > Miscellaneous > Data Asset > NA Configurator Theme.
2. Open it and change its Palette (Day and Night), Fonts, Sounds, Icons (a picture in place of a line icon, by its key) and Texts (a card's own name and description, by its key).
3. In Project Settings > Plugins > Ocean and Boats Simulator - Boat Picker > Look, set Theme to it. Night By Default opens the picker in its night lighting.

Check it works: press Play on L_NA_Start: the menus wear the interface theme, the boat picker its own.

If it does not: a screen already open keeps its old look until it is built again; reopen it, or restart Play.

9. Change or add sounds#

Every sound is a row of the sound table, DT_NA_Sounds (NavalArchitect > Audio). See Customizing.md, "Sounds", for every row.

1. Duplicate DT_NA_Sounds into your own folder.
2. In Project Settings > Plugins > Ocean and Boats Simulator > Sounds, set Sound Table to your copy.
3. To change a sound: open your table, select the row (for example Horn) and set its Sound, and its volume and pitch ranges.
4. To add an engine sound of your own: add two rows named <Prefix>_Idle and <Prefix>_Load (for example Engine_Jet_Idle and Engine_Jet_Load), and set the boat definition's Sound > Engine Sound Rows to the prefix (Engine_Jet). Horn Sound Row picks her horn's row the same way.
5. To play a row from Blueprint: Play Sound 2D Row, Play Sound at Location Row or Spawn Sound Attached Row.

Check it works: press Play and sound the horn (H), or open the throttle.

If it does not: a missing row or sound is silent, with one [NASOUND] warning in the Output Log. Check the row's name and the Sound Table setting.

10. Add a language or change a text#

• Texts that are data are changed where they are set: a boat's Display Name and Description (her definition, Picker), her configurations' and option rows' names and descriptions (Configurations), the start screen's Start Screen Title, Start Screen Subtitle and Loading Tips (Project Settings > Plugins > Ocean and Boats Simulator > Interface), and the boat picker's card texts (its theme's Texts, guide 8).
• The interface's own texts are in the C++ source. A translation is changed in the culture's NavalArchitect.po file, then compiled; the English wording is changed in the source, then gathered again.
• A new language: add its culture to the localization settings, gather, translate its .po file, import and compile. The Language setting in the menus lists a fixed set of languages: add the new one in C++ to offer it there.

The steps and the commands are in Customizing.md, "Languages"; packaging the languages is in QuickStart.md, "Packaging your game".

Check it works: switch the Language setting in the menus and open the screen again (menus already open change when they are opened again).

If it does not: the .locres file was not compiled again after the .po edit, or the culture is not staged in the packaging settings.

11. Switch off parts of the interface#

1. Open Project Settings > Plugins > Ocean and Boats Simulator > Interface.
2. Turn off what your game does not need:
   • Show Start Screen (off: the start map opens the demo map at once);
   • Show Boat Picker (off: Sail on the start screen goes straight to the demo map);
   • Show Helm Display, or single pages and windows in Helm Display Pages (Helm, Gauges, Chart, Radar, Sonar, Engines, Roll, Switches, Autopilot Window, Info Window);
   • Show Wave Tank Panel;
   • Show Help (the F1 key list and the line of keys at the top of the screen);
   • Show Loading Screen;
   • Show Pause Menu (Esc at sea).
3. To drop single entries of the start screen, open Start Menu Entries (it needs Show Start Screen on) and turn off what you do not want: With Quit off, Esc on the start screen no longer asks to quit (for a console or a kiosk).
   • Sail, Open Ocean, Wave Tank, Settings, Controls, Quit.
4. To drop single entries of the pause menu, open Pause Menu Entries (it needs Show Pause Menu on) and turn off what you do not want: Water Look is the Water group of sliders (Colour, Clarity, Foam) on the Sea And Wind page. It is made for trying the look of the water out, as in the demo. Switch it off in a game, and set the water in the ocean's material instead (guide 2). Without Sea And Wind, Water Look goes too.
   • Settings, Controls, Sea And Wind, Water Look, Shipyard, Restart, Right Her, 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.

The loading screen. With Show Loading Screen on, you can give it pictures of your own:

1. Interface > Loading Pictures: add an element for each picture. One is picked at random for each load.
2. Interface > Loading Screens: add an element for a map that needs a screen of its own. Set its Map, its Picture, its Title (shown in capitals) and its Subtitle (the line under the title; it shows with a Title).
3. The picture of a load 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 (guide 8). Use 16:9 pictures, 1920 x 1080 or larger.

The settings are saved in your project's Config/DefaultGame.ini. The physics never depends on the interface.

Check it works: press Play: the parts you turned off do not show, and a load shows your picture.

If it does not:

• Check that you changed the Ocean and Boats Simulator page, not the Boat Picker one.
• A group of switches is greyed out: its master switch is off (Show Start Screen for the start screen's entries, Show Pause Menu for the pause menu's, Show Loading Screen for the pictures).
• A load does not show the picture you set: the map is not listed in Loading Screens (check its Map), or the entry's Picture is empty and a picture of Loading Pictures was picked instead.

12. Add your own map, or remove one#

The scenario screen (the place picker the player sees after the boat picker) lists the maps the player can sail in. It reads them from one data table, the Places Table. One row is one map, with its start points.

The table is set in Project Settings > Plugins > Ocean and Boats Simulator > Shipyard > Places Table. By default it is DT_NA_Places (in NavalArchitect > Maps). It holds 3 rows: NA_Map_Demo, NA_Map_OpenOcean and NA_Map_WaveTank. A row is of the row structure NA Start Point:

The scenario screen lists every row, with its picture, its chart and its spots. With one row only, it shows no list.

The depth asset holds the ground and the sea floor of the map. It drives the chart, the echo sounder, the radar, and the waves steepening and breaking over shallows. Without it the sea is deep everywhere. It is read only for a map that is a row of the table (the row's Map names it).

First, keep your own copy of the table: a plugin update replaces the plugin's folder.

1. In the Content Browser, select DT_NA_Places and press Ctrl+W to duplicate it. Put the copy in your own folder.
2. Open Project Settings > Plugins > Ocean and Boats Simulator > Shipyard. Set Places Table to your copy.

Add a map: the easy way

1. Open your map. Load all of it. With World Partition, load every cell (Window > World Partition): only what is loaded is charted. Save the map.
2. Open Window > Place Actors, type NA Map Setup in its search box and drag NA Map Setup into the map. Put it in the middle of the water to chart, and leave its rotation at 0. A blue box shows the area charted: 4 km by 4 km at first. Size the box over the water with the Scale tool (R) or the actor's Scale X and Y (2 is 8 km). Its height does not matter.
3. In the Details panel, category Place, fill in Place Name, Region, Description, Picture, and the sea: Beaufort, Waves From, Swell Height, Swell Period (and Sky Place).
4. Optional, category Chart: Chart Texel (the chart's grid in m: 10 at first; a finer grid charts the coast closer, and takes longer and more memory; at most 2048 cells a side, so a very large box gets a coarser grid), Open Water Depth (the depth taken where nothing is found, -500 m), Places Table (empty: the one in Project Settings) and Row Name (empty: the map's name).
5. Place NA Start Spot actors where boats may start: type NA Start Spot in Place Actors and drag one onto the water, a quay or a harbour mouth for each spot. Rotate each one so that its orange arrow points the way the boat heads. For each, in category Start, set Spot Name, Kind (Port, Departure, Coast or Open Sea) and Description. Order sets the order of the spots: the lowest comes first, and it is the one picked when the map is.
6. Select the NA Map Setup. In its Details panel, category Chart, press Make Place.

Make Place traces the ground and the sea floor under the box (everything static that has collision), saves the result as DA_<Map>_Depth next to the map, and writes the map's row in the table, or updates it when it is there. The row's fields come from the actor's Place settings, its Spots from the NA Start Spot actors (their positions in km), its Map and Depth from the map and the saved chart. The Result field in the Details panel says what it did.

Both actors are editor only: they are not in a packaged game. Keep them in the map to press Make Place again after a change.

You can also add a row by hand: open the table, add a row, and fill in the fields above. Set Map, and Depth if you have a depth asset.

Check it works: Result says "Place ... written to ... with N spots; chart saved as ...". Open L_NA_Start, press Play, pick a boat: the scenario screen lists your map with its picture, its chart and its spots. Press Set sail: you start at the spot you picked, and the echo sounder shows the depth.

If it does not:

• Result says "Save the map first": save the map, then press Make Place again.
• Result says "No Places table": set Places Table here, or in Project Settings.
• Result says nothing was found under the box: the ground is not loaded, it has no collision, or the box is not over it. A map with no ground at all needs no depth asset: add its row by hand and leave Depth empty.
• Your map is not in the list: the table the row was written to is not the Places Table of Project Settings.
• The waves do not shoal or break on your coast: the row's Map is not this map, or its Depth is empty.
• The map does not load in a packaged game: list it in Project Settings > Packaging > List of maps to include in a packaged build.

Remove a map

1. Open your copy of the Places Table (made in the first steps above). Right-click the row of the map and choose Delete.
2. The start screen's Open Ocean and Wave Tank entries open their own maps without the table. For the map you removed, switch its entry off in Interface > Start Menu Entries (guide 11), or clear Open Ocean Map or Wave Tank Map under Interface > Maps. With Show Boat Picker off, Sail opens Demo Map: change that one too.

Check it works: the scenario screen no longer lists the map, and the start screen no longer offers it.

If it does not: you changed a table that is not the Places Table of Project Settings (the plugin's own, or an older copy).

13. Take the helm in your own game#

Use this when your game has a character of its own, and the player walks up to a boat and drives it. Your game mode and your character stay. The plugin gives the helm: its cameras, its keys, and if you want its helm display.

The nodes are static functions of NA Sea Trials Pawn, category Helm:

An example: one key boards the nearest boat, another leaves it.

1. Have a level with an NA Ocean and an NA Boat with a Boat Mesh Set (guide 1).
2. Open your Player Controller Blueprint. Put the key events there and not in the character: a character gets no key events while the player is at the helm, and Leave Helm has to work then. Pick two keys the helm does not use (QuickStart.md, "Sail", lists the helm keys).
3. On the Interact key: Get Controlled Pawn, then Get Actor Location, then Find Nearest Boat (World Context: self; Location: that location; Max Distance: 2000, or your own, in cm). Add Is Valid on the boat. On Is Valid, call Take Helm (Player: self; Boat: the boat; Helm Screen: on).
4. On the other key: call Leave Helm (Player: self; All Stop: on).

For one key that does both, call Get Helm Boat first: if it is valid, call Leave Helm; if not, do step 3.

Walking on a moving deck needs the hull to have collision. Open her hull static mesh and add collision (Collision menu of the Static Mesh Editor, or Collision Complexity > Use Complex Collision As Simple in its Details panel). Do the same for the deck parts a character steps on.

Check it works: press Play, walk up to the boat and press the Interact key. The plugin's cameras and keys take over, the helm display shows, and your character stays where it stood on her deck. Press the other key: you are the character again, upright, and your HUD is back.

If it does not:

• Find Nearest Boat returns none: the boat is further than Max Distance (cm, so 2000 is 20 m) from the point you give it.
• Nothing happens on the key: the event is in the character, or the key is also used by the helm.
• No helm display: Helm Screen is off, or Show Helm Display is off in Project Settings (guide 11).
• The character falls through the deck: the hull has no collision.
• Leave Helm returns none: the player is not at a helm taken with Take Helm.

Driving her from your own interface To show your own wheel, levers and gauges in place of the plugin's helm display:

1. Switch the helm display off: Project Settings > Plugins > Ocean and Boats Simulator > Interface, turn off Show Helm Display (and Show Help to drop the key list). Or call Take Helm with Helm Screen off.
2. Check that her helm is on: on the boat's Motion component (NA Ship Motion), category Motion > Helm, Helm must be on, or the helm functions do nothing. Take Helm turns it on, and Leave Helm turns it off. With your own pawn and no Take Helm, turn it on yourself.
3. From your widgets, call the helm functions of the Motion component: Helm Levers, Helm Levers Let Go, Helm Telegraph, Helm Wheel, Helm Set Wheel, Helm Midships, Helm All Stop, Helm Thrusters, Helm Autopilot, Helm Autopilot Adjust, Helm Tabs. BlueprintAPI.md, "Helm", says what each one does.
4. For your gauges, read the component's Speed Knots, Heel, Trim, Engine Revolutions and Throttle, and call Get Engine Load and Get Engine Rpm.

Check it works: press Play, work your widgets: the boat answers. If she does not, Helm is off (step 2).

14. What adapts by itself, and what does not#

Adapts by itself, from your data and settings:

• the boat picker: a card for every boat definition that can sail and is listed, her configurations, and her option rows (made by hand, or read from the tags of her Blueprint's components, guide 5);
• the scenario screen: a place for every row of the Places Table, with its picture, chart and spots (guide 12);
• the helm display's engine panels, which follow her number of engines;
• the helm display's radar key, dimmed on a boat without a radar scanner;
• the F1 key list, which shows only the lines for what she has (twin levers or a telegraph, thrusters, trim tabs, wipers, deck lights);
• the helm display's pages and windows, the start screen's and the pause menu's entries, and the loading screens, by the settings of guide 11;
• her engine and horn sounds, by her definition's sound rows.

Does not adapt, because it is fixed in C++:

• the pause menu's Controls page (a fixed list of keys);
• the key bindings themselves (Customizing.md, "Controls");
• the boat picker's hull colour swatches;
• the engine, propeller and stabiliser choices (Economy, Standard, Uprated; Short, Standard, Long; None, Fins, Gyro);
• the line icons (the themes can put a picture in place of an icon, by its key, but a new line icon is drawn in C++);
• the list of languages in the Language setting.

Every menu and screen is built in C++, with no Widget Blueprints: restyle them with the themes (guide 8), and change their layout or content in the C++ source (guide 15).

15. Where the source is#

The full C++ source ships with the plugin, in its Source folder: Plugins/NavalArchitect/Source in your project, or under the engine's Plugins folder when installed from the launcher. To change it, copy the plugin into your project's Plugins folder and make your project a C++ project (Tools > New C++ Class once), then build from your IDE.

The modules:

C++ code of your own uses the runtime module: add "NavalArchitect" to your module's dependencies (BlueprintAPI.md, "C++"). The automation tests are named NavalArchitect.*; run them from Tools > Session Frontend > Automation.