Gittes-archive/new-horizons
2
0
Fork 0
mirror of https://github.com/Outer-Wilds-New-Horizons/new-horizons.git synced 2025-12-11 20:15:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Start on docs redo

Browse Source
This commit is contained in:
Ben C 2022-07-23 17:01:30 -04:00
parent 59850e1875
commit 0f40e37d1c
No known key found for this signature in database
GPG Key ID: 7F8F04504B670474
15 changed files with 483 additions and 601 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
docs/content/pages/home.md
View File

@ -8,118 +8,11 @@ Sort_Priority: 100
# Outer Wilds New Horizons
This is the official documentation for [New Horizons](https://github.com/xen-42/outer-wilds-new-horizons), a framework for creating custom planets in the game [Outer Wilds](https://www.mobiusdigitalgames.com/outer-wilds.html) by Mobius Digital. Planets are created using simple JSON and XML files and are loaded at runtime. An [API]({{ "API"|route }}) is also provided for more advanced use-cases.
This is the official documentation for [New Horizons](https://github.com/xen-42/outer-wilds-new-horizons), a framework for creating custom planets in the game [Outer Wilds](https://www.mobiusdigitalgames.com/outer-wilds.html) by Mobius Digital. Planets are created using simple JSON and XML files and are loaded at runtime. An [API]({{ "API"|route }}) is also provided for more advanced use-cases.
## Getting Started
Before starting, go into your in-game mod settings for New Horizons and switch Debug mode on. This allows you to:
- Use the [Prop Placer tool]({{ "detailing"|route }}#using-the-prop-placer). This convienence tool allows you to place details in game and save your work to your config files.
- Print the position of what you are looking at to the logs by pressing "P". This is useful for determining locations to place props the Prop Placer is unable to, such as signal scope points or dialogue triggers.
- Use the "Reload Configs" button in the pause menu. This will restart the current solar system and update all the planets. Much faster than quitting and relaunching the game.
!!! alert-danger "Get VSCode"
Please get [VSCode](https://code.visualstudio.com/){ target="_blank" } or some other advanced text editor, as it will help highlight common errors.
Planets are created using a JSON file format structure, and placed in a folder called planets (or in any subdirectory of it) in the location where New Horizons is installed (by default this folder doesn't exist, you have to create it within the xen.NewHorizons directory). You can learn how the configs work by picking apart the [Real Solar System](https://github.com/xen-42/outer-wilds-real-solar-system){ target="_blank" } mod or the [New Horizons Examples](https://github.com/xen-42/ow-new-horizons-examples){ target="_blank" } mod.
To locate this directory, click the "⋮" symbol next to "New Horizons" in the Outer Wilds Mod Manager and then click "
show in explorer" in the pop-up.
![Click the three dots in the mod manager]({{ "images/home/mod_manager_dots.webp"|static }})
![Create a new folder named "planets"]({{ "images/home/create_planets.webp"|static }})
Planets can also be placed in a folder called planets within a separate mod, if you plan on releasing your planets on the mod database. The [Config Template](https://github.com/xen-42/ow-new-horizons-config-template){ target="_blank" } is available if you want to release your own planet mod using configs.
Now that you have created your planets folder, this is where you will put your planet config files. A config file will
look something like this:
```json
{
"name": "Wetrock",
"$schema": "https://raw.githubusercontent.com/xen-42/outer-wilds-new-horizons/main/NewHorizons/Schemas/body_schema.json",
"starSystem": "SolarSystem",
"Base": {
"groundSize": 100,
"surfaceSize": 101,
"surfaceGravity": 12,
"hasMapMarker": true
},
"Orbit": {
"semiMajorAxis": 1300,
"inclination": 0,
"primaryBody": "TIMBER_HEARTH",
"isMoon": true,
"isTidallyLocked": true,
"longitudeOfAscendingNode": 0,
"eccentricity": 0,
"argumentOfPeriapsis": 0
},
"Atmosphere": {
"size": 150,
"fogTint": {
"r": 200,
"g": 255,
"b": 255,
"a": 255
},
"fogSize": 150,
"fogDensity": 0.2,
"hasRain": true
},
"Props": {
"scatter": [
{
"path": "DreamWorld_Body/Sector_DreamWorld/Sector_DreamZone_1/Props_DreamZone_1/OtherComponentsGroup/Trees_Z1/DreamHouseIsland/Tree_DW_M_Var",
"count": 12
}
]
}
}
```
The first field you should have in any config file is the `name`. This should be unique in the solar system. If it
isn't, the mod will instead try to modify the planet that already has that name.
After `name` is `starSystem`. You can use this to place the planet in a different system accessible using a black-hole or via the ship's warp drive (accessible from the ship log computer). To ensure compatibility with other mods this name should be unique. After setting a value for this, the changes in the config will only affect that body in that star system. By default, it is "SolarSystem", which is the scene from the stock game.
Including the "$schema" line is optional, but will allow your text editor to highlight errors and auto-suggest words in your config. I recommend using VSCode as a text editor, but anything that supports Json files will work. Something as basic as notepad will work but will not highlight any of your errors.
The config file is then split into modules, each one with its own fields that define how that part of the planet will be generated. In the example above I've used the `Base`, `Orbit`, `Atmosphere`, and `Props` modules. A config file must have a `Base` and `Orbit` module, the rest are optional.
Each `{` must match up with a closing `}` to denote its section. If you don't know how JSONs work then check Wikipedia.
Modules look like this:
```json
{
"Star": {
"size": 3000,
"tint": {
"r": 201,
"g": 87,
"b": 55,
"a": 255
}
}
}
```
In this example the `Star` module has a `size` field and a `tint` field. Since the colour is a complex object it needs
another set of `{` and `}` around it, and then it has its own fields inside it : `r`, `g`, `b`, and `a`. Don't forget to put
commas after each field.
Most fields are either true/false, a decimal number, and integer number, or a string (word with quotation marks around
it).
To see all the different things you can put into a config file check out the [Celestial Body schema]({{ 'Celestial Body Schema'|route}}).
Check out the rest of the site for how to format [star system]({{ 'Star System Schema'|route}}), [dialogue]({{ 'Dialogue Schema'|route}}), [ship log]({{ 'Shiplog Schema'|route}}), and [translation]({{ 'Translation Schema'|route}}) files!
## Publishing Your Mod
Once your mod is complete, you can use the [planet creation template](https://github.com/xen-42/ow-new-horizons-config-template#readme){ target="_blank" } GitHub template.
For a guide on getting started an getting familiar with New Horizons, go to the [Getting Started]({{ "Getting Started"|route }}) page.
## Helpful Resources

47
docs/content/pages/tutorials/api.md
View File

@ -1,47 +0,0 @@
---
Title: API
Sort_Priority: 40
---
## How to use the API
First create the following interface in your mod:
```cs
public interface INewHorizons
{
void LoadConfigs(IModBehaviour mod);
GameObject GetPlanet(string name);
string GetCurrentStarSystem();
UnityEvent<string> GetChangeStarSystemEvent();
UnityEvent<string> GetStarSystemLoadedEvent();
GameObject SpawnObject(GameObject planet, Sector sector, string propToCopyPath, Vector3 position, Vector3 eulerAngles, float scale, bool alignWithNormal);
string[] GetInstalledAddons();
}
```
In your main `ModBehaviour` class you can get the NewHorizons API like so:
```cs
public class MyMod : ModBehaviour
{
void Start()
{
INewHorizons NewHorizonsAPI = ModHelper.Interaction.GetModApi<INewHorizons>("xen.NewHorizons");
}
}
```
You can then use the APIs `LoadConfigs()` method to load from a "planets" folder, or use the `GetPlanet()` method to get planets and do whatever with them. Just make sure you create planets in the `Start()` method or at least before the SolarSystem scene loads, or they will not be created.
The `GetChangeStarSystemEvent` and `GetStarSystemLoadedEvent` events let you listen in for when the player starts changing to a new system (called when entering a black hole or using the warp drive) and when the system is fully loaded in, respectively.
You can also use the `GetInstalledAddons` method to get a list of addons that are installed and enabled.
You can also use `SpawnObject` to directly copy a base-game GameObject to the specified position and rotation.

167
docs/content/pages/tutorials/details.md
View File

@ -1,167 +0,0 @@
---
Title: Detailing
Sort_Priority: 85
---
# Details/Scatterer
For physical objects there are currently two ways of setting them up: specify an asset bundle and path to load a custom asset you created, or specify the path to the item you want to copy from the game in the scene hierarchy. Use the [Unity Explorer](https://outerwildsmods.com/mods/unityexplorer){ target="_blank" } mod to find an object you want to copy onto your new body. Some objects work better than others for this. Good luck. Some pointers:
- Use "Object Explorer" to search
- Do not use the search functionality on Scene Explorer, it is really, really slow. Use the "Object Search" tab instead.
- Generally you can find planets by writing their name with no spaces/punctuation followed by "_Body".
- There's also [this community-maintained list of props](https://docs.google.com/spreadsheets/d/1VJaglB1kRL0VqaXhvXepIeymo93zqhWex-j7_QDm6NE/edit?usp=sharing) which you can use to find interesting props and check to see if they have collision.
## Using the Prop Placer
The Prop Placer is a convenience tool that lets you manually place details from inside the game. Once enabled, press "G" and your currently selected prop will be placed wherever your crosshair is pointing.
### Enabling
1. Pause the game. You will see an extra menu option titled "Toggle Prop Placer Menu". Click it
2. The prop placer menu should now be open. At the bottom of the menu, you will see a list of mods. Click yours.
1. This menu scrolls. If you do not see your mod, it may be further down the list.
3. The Prop Placer is now active! Unpause the game and you can now place Nomai vases using "G"
### How to Save
1. In the Prop Placer Menu, you will see a greyed out button titled "Update your mod's configs".
2. Click the small button to the left of it.
3. Click "Update your mod's configs" to save!
!!! alert-danger "IMPORTANT"
Your updated configs will save *only* to your mod's build folder, eg "AppData\Roaming\OuterWildsModManager\OWML\Mods\you.yourModName"
!!! alert-warning "WARNING"
Dying in-game will cause you to lose all work since you last saved. Make sure to save often.
What's that? You want to place something other than just vases? Well I can't say I agree with your choices, but here's how you would do that.
### How to Select Props
1. Pause the game again. The prop placer menu should still be visible.
2. At the top of the menu, you'll see a text box contianing the path for the vase. Replace this with the path for the prop you want to place. For example: `DreamWorld_Body/Sector_DreamWorld/Sector_DreamZone_1/Props_DreamZone_1/OtherComponentsGroup/Trees_Z1/DreamHouseIsland/Tree_DW_M_Var`
3. Tip: use the Unity Explorer mod to find the path for the object you want to place. You only have to do this once.
4. Unpause the game and press "G". Say hello to your new tree!
5. Pause the game again. You will now see the prop you just placed on the list of recently placed props just below the "path" text box.
6. Click on the button titled "Prefab_NOM_VaseThin". You can now place vases again.
### Extra features
1. Made a mistake? **Press the "-" key to undo.** Press the "+" key to redo.
2. If you have the Unity Explorer mod enabled, you can use this to tweak the position, rotation, and scale of your props. Your changes will be saved.
3. Want to save some recently placed props between game launches? On the recently placed props list, click the star next to the prop's name to favorite it.
4. Found a bug that ruined your configs? Check `AppData\Roaming\OuterWildsModManager\OWML\Mods\xen.NewHorizons\configBackups` for backup saves of your work. Folders are titled "\[date\]T\[time\]".
5. Want to add props to Ember Twin but don't feel like making a config file for it? We got you! Place that prop and the config file will be created automatically on your next save.
6. This even works for planets that were created by other mods!
## Asset Bundles
Here is a template project: [Outer Wilds Unity Template](https://github.com/xen-42/outer-wilds-unity-template){ target="_blank" }
The template project contains ripped versions of all the game scripts, meaning you can put things like DirectionalForceVolumes in your Unity project to have artificial gravity volumes loaded right into the game.
If for whatever reason you want to set up a Unity project manually instead of using the template, follow these instructions:
1. Start up a Unity 2017 project (I use Unity 2017.4.40f1 (64-bit), so if you use something else I can't guarantee it will work). The DLC updated Outer Wilds to 2019.4.27 so that probably works, but I personally haven't tried it.
2. In the "Assets" folder in Unity, create a new folder called "Editor". In it create a file called "CreateAssetBundle.cs" with the following code in it:
```cs
using UnityEditor;
using UnityEngine;
using System.IO;
public class CreateAssetBundles
{
[MenuItem("Assets/Build AssetBundles")]
static void BuildAllAssetBundles()
{
string assetBundleDirectory = "Assets/StreamingAssets";
if (!Directory.Exists(Application.streamingAssetsPath))
{
Directory.CreateDirectory(assetBundleDirectory);
}
BuildPipeline.BuildAssetBundles(assetBundleDirectory, BuildAssetBundleOptions.None, BuildTarget.StandaloneWindows64);
}
}
```
3. Create your object in the Unity scene and save it as a prefab.
4. Add all files used (models, prefabs, textures, materials, etc.) to an asset bundle by selecting them and using the dropdown in the bottom right. Here I am adding a rover model to my "rss" asset bundle for the Real Solar System add-on.
![setting asset bundle]({{ 'images/detailing/asset_bundle.webp'|static }})
5. In the top left click the "Assets" drop-down and select "Build AssetBundles". This should create your asset bundle in a folder in the root directory called "StreamingAssets".
6. Copy the asset bundle and asset bundle .manifest files from StreamingAssets into your mod's "planets" folder. If you did everything properly they should work in game. To double-check everything is included, open the .manifest file in a text editor to see the files included and their paths.
## Importing a planet's surface from Unity
Making a planet's entire surface from a Unity prefab is the exact same thing as adding one single big detail at position (0, 0, 0).
## Examples
To add a Mars rover to the red planet in [RSS](https://github.com/xen-42/outer-wilds-real-solar-system), its model was put in an asset bundle as explained above, and then the following was put into the `Props` module:
```json
{
"Props": {
"Details": [
{
"assetBundle": "planets/assetbundle/rss",
"path": "Assets/RSS/Prefabs/Rover.prefab",
"position": {
"x": 146.5099,
"y": -10.83688,
"z": -36.02736
},
"alignToNormal": true
}
]
}
}
```
To scatter 12 trees from the Dream World around Wetrock in [NH Examples](https://github.com/xen-42/ow-new-horizons-examples) , the following was put into the `Props` module:
```json
{
"Props": {
"Scatter": [
{
"path": "DreamWorld_Body/Sector_DreamWorld/Sector_DreamZone_1/Props_DreamZone_1/OtherComponentsGroup/Trees_Z1/DreamHouseIsland/Tree_DW_M_Var",
"count": 12
}
]
}
}
```
You can swap these around too. The following would scatter 12 Mars rovers across the planet and place a single tree at a given position:
```json
{
"Props": {
"Details": [
{
"path": "DreamWorld_Body/Sector_DreamWorld/Sector_DreamZone_1/Props_DreamZone_1/OtherComponentsGroup/Trees_Z1/DreamHouseIsland/Tree_DW_M_Var",
"position": {
"x": 146.5099,
"y": -10.83688,
"z": -36.02736
},
"alignToNormal": true
}
],
"Scatter": [
{
"assetBundle": "planets/assetbundle/rss",
"path": "Assets/RSS/Prefabs/Rover.prefab",
"count": 12
}
]
}
}
```
## Use the schema
To view additional options for detailing, check [the schema]({{ "Celestial Body Schema"|route}}#Props_details)

164
docs/content/pages/tutorials/dialogue.md
View File

@ -1,164 +0,0 @@
---
Title: Dialogue
Description: Guide to making dialogue in New Horizons
Sort_Priority: 50
---
# Dialogue
This page goes over how to use dialogue in New Horizons.
# Understanding Dialogue
## Dialogue Tree
A dialogue tree is an entire conversation, it's made up of dialogue nodes.
## Dialogue Node
A node is a set of pages shown to the player followed by options the player can choose from to change the flow of the conversation.
## Condition
A condition is a yes/no value stored **for this loop and this loop only**. It can be used to show new dialogue options, stop someone from talking to you (looking at you Slate), and more.
## Persistent Condition
A persistent condition is similar to a condition, except it *persists* through loops, and is saved on the player's save file.
## Remote Trigger
A remote trigger is used to have an NPC talk to you from a distance; ex: Slate stopping you for the umpteenth time to tell you information you already knew.
# Example XML
Here's an example dialogue XML:
```xml
<!-- Example Dialogue -->
<!-- All files must have `DialogueTree` as the root element, the xmlns:xsi=... and xsi:noNamespaceSchemaLocation=... is optional but provides improved error checking if your editor supports it -->
<DialogueTree xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/xen-42/outer-wilds-new-horizons/main/NewHorizons/Schemas/dialogue_schema.xsd">
<NameField>EXAMPLE NPC</NameField> <!-- The name of this character -->
<DialogueNode> <!-- A dialogue node is a set of pages displayed to the player optionally followed by options -->
<Name>Start</Name> <!-- The name of this node, used to go to this node from another node -->
<EntryCondition>DEFAULT</EntryCondition> <!-- The condition that must be met for this node to be reached; A file should always have a node with "DEFAULT" -->
<Dialogue> <!-- The actual dialogue we want to show the player -->
<Page>Start</Page> <!-- A single page of the dialogue -->
<Page>Start Part 2</Page> <!-- Another page -->
</Dialogue>
<DialogueOptionsList> <!-- Show options the player can choose from when the character is done talking -->
<DialogueOption> <!-- A single option the player can pick -->
<Text>Goto 1</Text> <!-- The text to display for the option -->
<DialogueTarget>1</DialogueTarget> <!-- The name of the node to jump to -->
</DialogueOption>
<!-- A few more options... -->
<DialogueOption>
<Text>Goto 2</Text>
<DialogueTarget>2</DialogueTarget>
</DialogueOption>
<DialogueOption>
<Text>Goto End</Text>
<DialogueTarget>End</DialogueTarget>
</DialogueOption>
</DialogueOptionsList>
</DialogueNode>
<DialogueNode> <!-- Another node -->
<Name>1</Name> <!-- Name of the node -->
<!-- (Note the lack of an EntryCondition) -->
<Dialogue>
<Page>This is 1</Page>
</Dialogue>
<DialogueOptionsList>
<DialogueOption>
<Text>Goto 2</Text>
<DialogueTarget>2</DialogueTarget>
</DialogueOption>
<DialogueOption>
<Text>Goto End</Text>
<DialogueTarget>End</DialogueTarget>
</DialogueOption>
</DialogueOptionsList>
</DialogueNode>
<DialogueNode> <!-- Another node why not -->
<Name>2</Name>
<Dialogue>
<Page>This is 2</Page>
</Dialogue>
<DialogueOptionsList>
<DialogueOption>
<Text>Goto 1</Text>
<DialogueTarget>1</DialogueTarget>
</DialogueOption>
<DialogueOption>
<Text>Goto End</Text>
<DialogueTarget>End</DialogueTarget>
</DialogueOption>
</DialogueOptionsList>
</DialogueNode>
<DialogueNode> <!-- The end node -->
<Name>End</Name>
<Dialogue>
<Page>This is the end</Page>
</Dialogue>
<!-- When a node doesn't have any options defined the dialogue box will close once the pages have been read -->
</DialogueNode>
</DialogueTree>
```
# Using the XML
To use the dialogue XML you have created, you simply need to reference it in the `dialogue` prop
```json
{
"Props": {
"dialogue": [
{
"position": {"x": 5, "y": 10, "z": 0},
"xmlFile": "planets/path/to/your_file.xml"
}
]
}
}
```
# Dialogue Config
To view the options for the dialogue prop, check [the schema]({{ "Celestial Body Schema"|route }}#Props_dialogue)
# Controlling Conditions
You can set condition in dialogue with the `<SetCondition>` and `<SetPersistentCondition>` tags
```xml
<DialogueNode>
<!-- ... -->
<SetCondition>EXAMPLE_CONDITION</SetCondition>
<SetPersistentCondition>EXAMPLE_P_CONDITION</SetPersistentCondition>
<!-- ... -->
</DialogueNode>
```
# Dialogue Options
There are many control structures for dialogue options to hide/reveal them if conditions are met. Take a look at [the DialogueOption schema]({{ "Dialogue Schema"|route }}#DialogueTree-DialogueNode-DialogueOptionsList-DialogueOption-DialogueTarget) for more info.
# Controlling Flow
In addition to `<DialogueOptions>`, there are other ways to control the flow of the conversation.
## DialogueTarget
Defining `<DialogueTarget>` in the `<DialogueNode>` tag instead of a `<DialogueOption>` will make the conversation go directly to that target after the character is done talking.
## DialogueTargetShipLogCondition
Used in tandum with `DialogueTarget`, makes it so you must have a [ship log fact]({{ "Ship Log"|route }}#explore-facts) to go to the next node.

255
docs/content/pages/tutorials/getting_started.md Normal file
View File

@ -0,0 +1,255 @@
---
Title: Getting Started
Sort_Priority: 100
---
# Getting Started
Congrats on taking the first step to becoming an addon developer!
This tutorial will outline how to begin learning to use new horizons.
## Recommended Tools
It's strongly recommended you get [VSCode](https://code.visualstudio.com/){ target="_blank" } to edit your files, as it can provide syntax and error highlighting.
## Using The Sandbox
Making an entirely separate addon can get a little complicated, so New Horizons provides a way to play around without the need to set up a full addon.
To get started, navigate to your mod manager and click the ⋮ symbol, then select "Show In Explorer".
![Select "Show in explorer"]({{ "images/getting_started/mod_manager_show_in_explorer.webp"|static }})
Now, in explorer and create a new folder named "planets". As the name suggests, New Horizons will search the files in this folder for planets to generate.
## Making Your First Planet
To get started, create a new file in this folder called `wetrock.json`, we'll explain what that .json at the end means soon.
Open this file in VSCode (you can do so by right-clicking the file and clicking "Open with Code")
Once in VSCode, paste this code into the file:
```json
{
"name": "Wetrock",
"$schema": "https://raw.githubusercontent.com/xen-42/outer-wilds-new-horizons/main/NewHorizons/Schemas/body_schema.json",
"starSystem": "SolarSystem",
"Base": {
"groundSize": 100,
"surfaceSize": 101,
"surfaceGravity": 12,
"hasMapMarker": true
},
"Orbit": {
"semiMajorAxis": 1300,
"primaryBody": "TIMBER_HEARTH",
"isMoon": true,
"isTidallyLocked": true
},
"Atmosphere": {
"size": 150,
"fogTint": {
"r": 200,
"g": 255,
"b": 255,
"a": 255
},
"fogSize": 150,
"fogDensity": 0.2,
"hasRain": true
}
}
```
This language is **J**ava**S**cript **O**bject **N**otation, or JSON.
It's a common way to convey data in many programs.
## Understanding JSON
All JSON files start out with an `object`, or a set of key value mappings, for example is we represent a person as JSON it might look like:
```json
{
"name": "Jim"
}
```
Those braces (`{}`) denote an object, and by doing `"name": "Jim"` we're saying that the name of this object (in this case person) is Jim
`"name"` is the key, and `"Jim"` is the value.
Objects can have multiple keys as well, as long as you separate them by commas:
```json
{
"name": "Jim",
"age": 23
}
```
But wait! why is `Jim` in quotation marks while `23` isn't? that's because of a little something called data types.
Each value has a datatype, in this case `"Jim"` is a `string`, because it represents a *string* of characters.
Age is a `number`, it represents a numerical value. If we put 23 in quotation marks, its data type switches from a number to a string.
And if we remove the quotation marks from `"Jim"` we get a syntax error. Datatypes are a common source of errors, which is why we recommend using an editor like VSCode.
### JSON Data Types
Here's a list of data types you'll use when making your addons:
#### String
A string of characters surrounded in quotation marks
```json
"Im a string!"
```
If you need to use quotation marks within your string, place a backslash (`\`) before them
```json
"\"Im a string!\" - Mr. String Stringerton"
```
#### Number
A numerical value, can be negative and have decimals, **not** surrounded in quotation marks
```json
-25.3
```
#### Boolean
A `true` or `false` value, think of it like an on or off switch
```json
true
```
#### Array
A set of values, values can be of any data type. Items are seperated by commas
```json
[23, 45, 56]
```
```json
["Bob", "Suzy", "Mark"]
```
And they can be empty like so:
```json
[]
```
#### Object
A set of key value pairs, where each key is a string and each value can be of any data type (even other objects!)
```json
{
"name": "Jim",
"age": 23,
"isMarried": false,
"clothes": {
"shirtColor": "red",
"pantsColor": "blue"
},
"friends": ["Bob", "Wade"],
"enemies": []
}
```
## Back to Wetrock
Now that we understand JSON better, let's look at that config file again:
```json
{
"name": "Wetrock",
"$schema": "https://raw.githubusercontent.com/xen-42/outer-wilds-new-horizons/main/NewHorizons/Schemas/body_schema.json",
"starSystem": "SolarSystem",
"Base": {
"groundSize": 100,
"surfaceSize": 101,
"surfaceGravity": 12,
"hasMapMarker": true
},
"Orbit": {
"semiMajorAxis": 1300,
"primaryBody": "TIMBER_HEARTH",
"isMoon": true,
"isTidallyLocked": true
},
"Atmosphere": {
"size": 150,
"fogTint": {
"r": 200,
"g": 255,
"b": 255,
"a": 255
},
"fogSize": 150,
"fogDensity": 0.2,
"hasRain": true
}
}
```
Here we can see we have a planet object, which name is "Wetrock", and is in the "SolarSystem" (Base-game) star system.
It has an object called Base, which has a groundSize of 100, and a surfaceSize of 101, and the list continues on.
Alright so now that we understand how the file is structures, let's look into what each value actually does:
- `name` simply sets the name of the planet
- `$schema` we'll get to in a second
- `starSystem` specifies what star system this planet is located in, in this case we're using the base game star system, so we put "SolarSystem"
- Then it has an object called `Base`
- Base has a `groundSize` of 100, this generates a perfect sphere that is 100 units in radius as the ground of our planet
- It also has a `surfaceSize` of 101, surface size is used in many calculations, it's generally good to set it to a bit bigger than ground size.
- `surfaceGravity` describes the strength of gravity on this planet, in this case it's 12 which is the same as Timber Hearth
- `hasMapMarker` tells new horizons that we want this planet to have a marker on the map screen
- Next it has another object called `Orbit`
- `semiMajorAxis` specifies the radius of the orbit (how far away the body is from its parent)
- `primaryBody` is set to TIMBER_HEARTH, this makes our planet orbit timber hearth
- `isMoon` simply tells the game how close you have to be to the planet in map mode before its name appears
- `isTidallyLocked` makes sure that one side of our planet is always facing timber hearth (the primary body)
- Finally, we have `Atmosphere`
- Its `size` is 150, this simply sets how far away from the planet our atmosphere stretches
- Its `fogTint` is set to a color which is an object with r, g, b, and a properties (properties is another word for keys)
- `fogSize` determines how far away the fog stretches from the planet
- `fogDensity` is simply how dense the fog is
- `hasRain` makes rainfall on the planet
### What's a Schema?
That `$schema` property is a bit special, it instructs VSCode to use a pre-made schema to provide a better editing experience.
With the schema you get:
- Automatic descriptions for properties when hovering over keys
- Automatic error detection for incorrect data types or values
- Autocomplete, also called IntelliSense
## Testing The Planet
With the new planet created (*and saved!*), launch the game through the mod manager and click resume expedition. If all went well you should be able to open your map and see wetrock orbiting Timber Hearth.
If you run into issues please make sure:
- You placed the JSON file in a folder called `planets` in the New Horizons mod folder
- There are no red or yellow squiggly lines in your file
## Experiment!
With that, try tweaking some value like groundSize and semiMajorAxis, get a feel for how editing JSON works.
## Reloading Configs
It can get annoying when you have to keep closing and opening the game over and over again to test changes, that's why New Horizons has a "Reload Configs" feature.
To enable it, head to your Mods menu and select New Horizons and check the box that says Debug, this will cause a "Reload Configs" option to appear in your pause menu which will reload changes from your filesystem.
You may also notice blue and yellow logs start appearing in your console, this is New Horizons providing additional info on what it's currently doing, it can be helpful when you're trying to track down an issue.
## More Objects
Base, Atmosphere, and Orbit aren't all the objects (or "modules") there are to use, to learn about these other objects, you'll need to learn how to use the "Schemas" section of this site, which lists every possible property you can put in your files.
**Next Up: [Reading Schemas]({{ "Reading Schemas"|route }})**

148
docs/content/pages/tutorials/planet_gen.md Normal file
View File

@ -0,0 +1,148 @@
---
Title: Planet Generation
Sort_Priority: 80
---
# Planet Generation
The first thing you'll need to create on a planet is its surface, this can be done in a variety of ways
## Surface
Ground of the planet
### Ground Size
`groundSize` is the absolute simplest way to make a planet's surface, you simply specify a radius and New Horizons will make a sphere for you.
```json
{
"name": "My Cool Planet",
"Base": {
"groundSize": 100
}
}
```
### Heightmaps
Heightmaps are a way to generate unique terrain on your planet. First you specify a maximum and minimum height, and then specify a [heightMap]({{ "Celestial Body Schema"|route }}#HeightMap_heightMap) image. The more white a section of that image is, the closer to `maxHeight` that part of the terrain will be. Finally, you specify a `textureMap` which is an image that gets applied to the terrain.
<!-- TODO: ADD HEIGHTMAP EXAMPLES -->
```json
{
"name": "My Cool Planet",
"HeightMap": {
"minHeight": 5,
"maxHeight": 100,
"heightMap": "planets/assets/my_cool_heightmap.png",
"textureMap": "planets/assets/my_cool_texturemap.png"
}
}
```
There are also tools to help generate these images for you such as [Textures For Planets](https://www.texturesforplanets.com/){ target="_blank" }.
## Variable Size Modules
The following modules support variable sizing, meaning they can change scale over the course of the loop.
- Water
- Lava
- Star
- Sand
- Funnel
- Ring
To do this, simply specify a `curve` property on the module
```json
{
"name": "My Cool Planet",
"Water": {
"curve": [
{
"time": 0,
"value": 100
},
{
"time": 22,
"value": 0
}
]
}
}
```
This makes the water on this planet shrink over the course of 22 minutes.
## Quantum Planets
In order to create a quantum planet, first create a normal planet. Then, create a second planet config with the same `name` as the first and `isQuantumState` set to `true`.
This makes the second planet a quantum state of the first, anything you specify here will only apply when the planet is in this state.
```json
{
"name": "MyPlanet",
"Orbit": {
"semiMajorAxis": 5000,
"primaryBody": "Sun"
}
}
```
```json
{
"name": "MyPlanet",
"isQuantumState": true,
"Orbit": {
"semiMajorAxis": 1300,
"primaryBody": "TIMBER_HEARTH"
}
}
```
## Barycenter (Focal Point)
To create a binary system of planets (like ash twin and ember twin), first create a config with `FocalPoint` set
```json
{
"name": "My Focal Point",
"Orbit": {
"semiMajorAxis": 22000,
"primaryBody": "Sun"
},
"FocalPoint": {
"primary": "Planet A",
"secondary": "Planet B"
}
}
```
Now in each config set the `primaryBody` to the focal point
```json
{
"name": "Planet A",
"Orbit": {
"primaryBody": "My Focal Point",
"semiMajorAxis": 0,
"isTidallyLocked": true,
"isMoon": true
}
}
```
```json
{
"name": "Planet B",
"Orbit": {
"primaryBody": "My Focal Point",
"semiMajorAxis": 440,
"isTidallyLocked": true,
"isMoon": true
}
}
```

78
docs/content/pages/tutorials/reading_schemas.md Normal file
View File

@ -0,0 +1,78 @@
---
Title: Reading Schemas
Sort_Priority: 90
---
# Reading Schema Pages
Reading and understanding the schema pages are key to knowing how to create planets. While these tutorials may be helpful, they won't cover everything, and new features may be added before the tutorial on them can be written.
## Celestial Body Schema
The [celestial body schema]({{ "Celestial Body Schema"|route }}) is the schema for making planets, there are other schemas which will be explained later but for now let's focus on this one.
![The Celestial Body Schema Page]({{ "images/reading_schemas/body_schema_1.webp"|static }})
As you can see the type of this is `object`, which we talked about in the previous section.
We can also observe a blue badge that says "No Additional Properties", this signifies that you can't add keys to the object that aren't in the schema, for example:
```json
{
"name": "Wetrock",
"coolKey": "Look at my cool key!"
}
```
Will result in a warning in VSCode. Now, this will *not* prevent the planet from being loaded, however you should still avoid doing it.
## Simple Properties
![The name property on the celestial body schema]({{ "images/reading_schemas/body_schema_2.webp"|static }})
Next up let's look at `name`, this field is required, meaning you *have* to have it for a planet to load.
When we click on name we first see a breadcrumb, this is essentially a guide of where you are in the schema, right now we're in the name property of the root (topmost) object.
We can also see it's description, its type is `string`, and that it requires at least one character (so you can't just put `""`).
Badges can also show stuff such as the default value, the minimum and maximum values, and more.
## Object Properties
![The Base object on the celestial body schema]({{ "images/reading_schemas/body_schema_3.webp"|static }})
Next let's look at an `object` withing our root `object`, let's use `Base` as the example.
Here we can see it's similar to our root object, in that it doesn't allow additional properties.
We can also see all of its properties listed out.
## Array Properties
Now let's take a look over at [removeChildren]({{ "Celestial Body Schema"|route }}#removeChildren) to see how arrays work (if you're wondering how you can get the page to scroll to a specific property, simply click on the property and copy the URL in your URL bar)
![The curve property on a star in the celestial body schema]({{ "images/reading_schemas/body_schema_4.webp"|static }})
Here we can see that the type is an `array`, and each item in this array must be a `string`
## Some Vocabulary
- GameObject: Essentially just any object in, well, the game. You can view these object in a tree-like structure with the [Unity Explorer](https://outerwildsmods.com/mods/unityexplorer) mod. Every GameObject has a path, which is sort of like a file path in that it's a list of parent GameObjects seperated by forward slashes followed by the GameObject's name.
- Component: By themselves, a GameObject doesn't actually *do* anything, components provide stuff like collision, rendering, and logistics to GameObjects
- Config: Just another name for a JSON file "planet config" simply means a json file that describes a planet
- Module: A specific section of the config (e.g. Base, Atmosphere, etc), these usually start with capital letters
## Note About File Paths
Whenever a description refers to the "relative path" of a file, it means relative to the mod's directory, this means you **must** include the `planets` folder in the path:
```json
"planets/assets/images/MyCoolImage.png"
```
## Other Schemas
There are other schemas available, some are for JSON, and some are for XML.
## Moving Forward
Now that you know how to read the schema pages, you can understand the rest of this site. A lot of the other tutorials here will often tell you to take a look at schemas to explain what certain properties do.
**Next Up: [Planet Generation]({{ "Planet Generation"|route }})**

46
docs/content/pages/tutorials/star_system.md
View File

@ -1,46 +0,0 @@
---
Title: Star System
Description: A guide to editing a custom star system in New Horizons
Sort_Priority: 90
---
# Intro
Welcome! This page outlines how to edit a custom star system.
## Getting Started
Star Systems are placed in a folder called systems within your mod folder.
The name of your star system config must be the same as the unique id used in the `starSystem` field of your planet configs. Example: `xen.RealSolarSystem.json`.
A star system config file will look something like this:
```json
{
"$schema": "https://raw.githubusercontent.com/xen-42/outer-wilds-new-horizons/main/NewHorizons/Schemas/star_system_schema.json",
"coords": {
"x": [ 4, 0, 3, 1 ],
"y": [ 0, 5, 4 ],
"z": [ 5, 4, 0, 3, 1 ]
},
"vesselPosition": {
"x": 0,
"y": 0,
"z": 8000
}
}
```
To see all the different things you can put into a config file check out the [Star System Schema]({{ 'Star System Schema'|route}}).
## Vessel Coordinates
You can warp to custom star systems via the Nomai vessel. Each coordinate has to be 2-6 points long.
These are the points for each coordinate node. When making your unique coordinate you should only use each point once.
![nomaiCoordinateIndexes]({{ "images/star_system/nomai_coordinate_indexes.webp"|static }})
### Hearthian Solar System Vessel Coordinates
You can use these coordinates to warp back to the hearthian solar system.
![hearthianSolarSystemCoordinates]({{ "images/star_system/hearthian_solar_system_coordinates.webp"|static }})

34
docs/content/pages/tutorials/translation.md
View File

@ -1,34 +0,0 @@
---
Title: Translations
Sort_Priority: 60
---
## Translations
There are 12 supported languages in Outer Wilds: english, spanish_la, german, french, italian, polish, portuguese_br, japanese, russian, chinese_simple, korean, and turkish.
All translations must go in a folder in the root directory called "translations".
In this folder you can put json files with the name of the language you want to translate for. Inside this file just follow the translation schema.
Here's an example, for `russian.json`:
```json
{
"$schema": "https://raw.githubusercontent.com/xen-42/outer-wilds-new-horizons/main/NewHorizons/Schemas/translation_schema.json",
"DialogueDictionary" :
{
"Fred" : "Фред",
"You looking at something?" : "Ты что-то искал?",
"Aren't you guys all supposed to be dead?" : "А разве номаи не вымерли?",
"OH MY GOD A LIVING NOMAI AHHH WHAT HOW?!" : "ААААА, ЖИВАЯ НОМАИ?!"
},
"ShipLogDictionary" :
{
"Unexpected guests" : "Незванные гости",
"Visitors" : "Гости",
"When I went to sleep by the campfire only Slate was here, who are these characters?" : "Когда я ложился спать у костра здесь был только Сланец. Кто все остальные?",
"I met a talking jellyfish. His name is Geswaldo!" : "Я встретил говорящую медузу. Его зовут Гесвальдо!"
}
}
```

34
docs/content/pages/tutorials/update_existing.md
View File

@ -1,34 +0,0 @@
---
Title: Update Planets
Sort_Priority: 80
---
## Update Existing Planets
Similar to above, make a config where "Name" is the name of the planet. The name should be able to just match their in-game english names, however if you encounter any issues with that here are the in-code names for planets that are guaranteed to work: `SUN`, `CAVE_TWIN` (Ember Twin), `TOWER_TWIN` (Ash Twin), `TIMBER_HEARTH`, `BRITTLE_HOLLOW`, `GIANTS_DEEP`, `DARK_BRAMBLE`, `COMET` (Interloper), `WHITE_HOLE`, `WHITE_HOLE_TARGET` (Whitehole station I believe), `QUANTUM_MOON`, `ORBITAL_PROBE_CANNON`, `TIMBER_MOON` (Attlerock), `VOLCANIC_MOON` (Hollow's Lantern), `DREAMWORLD`, `MapSatellite`, `RINGWORLD` (the Stranger).
Only some of the above modules are supported (currently) for existing planets. Things you cannot modify for existing planets include: heightmaps, procedural generation, gravity, or their orbits. You also can't make them into stars or binary focal points (but why would you want to, just delete them and replace them entirely). However this still means there are many things you can do: completely change their atmospheres, give them rings, asteroid belts, comet tails, lava, water, prop details, or signals.
You can also delete parts of an existing planet. Here's part of an example config which would delete the rising sand from Ember Twin:
```json
{
"name": "Ember Twin",
"removeChildren": [
"SandSphere_Rising"
]
}
```
In `childrenToDestroy` you list the relative paths for the children of the planet's gameObject that you want to delete.
## Destroy Existing Planets
You do this (but with the appropriate name) as its own config.
```json
{
"name" : "Ember Twin",
"destroy" : true
}
```
Remember that if you destroy Timber Hearth you better put a `Spawn` module on another planet. If you want to entirely replace the solar system you can destroy everything, including the sun. Also, deleting a planet destroys anything orbiting it, so if you want to replace the solar system you can just destroy the sun. If you're making a brand new star system, you don't have to worry about deleting any existing planets; they won't be there.

BIN
docs/content/static/images/getting_started/mod_manager_show_in_explorer.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

BIN
docs/content/static/images/reading_schemas/body_schema_1.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
docs/content/static/images/reading_schemas/body_schema_2.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.6 KiB

BIN
docs/content/static/images/reading_schemas/body_schema_3.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
docs/content/static/images/reading_schemas/body_schema_4.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB