# Databox Object

## Databox Object

[![editorOverview](https://github.com/doorfortyfour/DataboxDocumentation/raw/master/docs/img/editorOverview.png)](https://github.com/doorfortyfour/DataboxDocumentation/blob/master/docs/img/editorOverview.png)

The Databox object serves as a container for your loaded data. Your data is saved to a file.\
Depending on your project you can have multiple Databox objects or just one which loads different files at runtime.\
When referencing a Databox object you have access to several methods for accessing the data, loading and saving at runtime.

### Configuration

[![configuration](https://github.com/doorfortyfour/DataboxDocumentation/raw/master/docs/img/configuration.png)](https://github.com/doorfortyfour/DataboxDocumentation/blob/master/docs/img/configuration.png)

#### Save path

> Before you can start adding data to your Databox object. You will need to specify a file name and a save path in the config. menu.

`File name`\
The file name relative to the chosen save folder. You can also specify a subfolder.

> Please note: due to the nature of how text/binary files are being loaded from the Resources folder by Unity, you will need to specify either .txt or .json as the file extension.

`Persistent Data Path:`\
Should be used for save game data only. Do not use it for your initial database data as it will not be included in a build.

`Streaming Asset Path:`\
Uses the "StreamingAssets" folder inside of your project. Great for files that should be loaded during runtime.

`Resources:`\
Use the resources path for loading the database file from a resources folder. It's not possible to save to a resources folder during runtime.

`PlayerPrefs:`\
Player prefs are a good way to create save games at runtime. Do not use it for your initial database data as it will not be included in a build.

> Make sure to check out the official Unity documentation regarding the different save paths:

[Persistent data path](https://docs.unity3d.com/ScriptReference/Application-persistentDataPath.html)\
[Streaming Assets](https://docs.unity3d.com/ScriptReference/Application-streamingAssetsPath.html)

#### Serializer

Databox supports two different serializers. If you want to know more about those, please have a look at this page here:\
[Serializers](https://odininspector.com/odin-serializer)

**Full Serializer**

`Encryption`\
Databox supports a simple XOR encryption. When enabled you'll need to provide an encryption key.

`Compress Json` Compressing the json file significantly reduces the file size. On the other hand, the json file is no longer easy to read in a text editing tool.

**Odin Serializer**

`Encryption`\
Databox supports a simple XOR encryption. When enabled you'll need to provide an encryption key.

`Data Format`\
Odin serializer supports two different data formats.\
\*JSON: Saves the data in a json formated file\
\*Binary: Saves the data in a binary formated file. Usually smaller file size compared to json.

#### Editor

`Automatic save`\
When enabled, Databox saves all changes made automatically. (Only in editor)

`Automatic load`\
When enabled, Databox loads the data automatically when the Databox object is being selected in the editor.

!> You will still need to load the data at runtime.

`Debug Mode`\
By enabling debug mode, Databox will create console logs on several events.

`Entries per page`\
Configure how many entries should be displayed per page in the Databox editor.

### Generate Keys

[![generateKeys](https://github.com/doorfortyfour/DataboxDocumentation/raw/master/docs/img/generatekeys.png)](https://github.com/doorfortyfour/DataboxDocumentation/blob/master/docs/img/generatekeys.png)

Instead of using strings for calling GetData and AddData - which can be error prone - you can generate static keys from your DataboxObject. Another great advantage is, that static keys are structured in classes and sub-classes based on tables and entries.

1. Simply click on the Generate Keys button in the Databox Object editor.
2. Select a file name and click on save.

**Example:**\
The keys are now accessible by using the `databox object name + "_KEYS"`. Let's assume we have a DataboxObject called PlayerData then we can use:

```csharp
    // Data is the table name - so we use TableName to access the static key
    PlayerData_KEYS.Data.TableName
    // Player is the entry name inside of the table Data - so we use EntryName to access the static key 
    PlayerData_KEYS.Data.Player.EntryName   
    // Health is located inside of the player entry - so we can simply use the _Health key.
    PlayerData_KEYS.Data.Player._Health
```

**GetData Example:**

```csharp
    public DataboxObject data;
    var health = data.GetData<IntType>(PlayerData_KEYS.Data.TableName, PlayerData_KEYS.Data.Player.EntryName, PlayerData_KEYS.Data.Player._Health);
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://giantgrey.gitbook.io/databox-documentation/databox-object.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.