Variables & Data Storage

Overview
Chances are you'll eventually want to save some information about the player. It may be a name, some stats, the amount of in-game currency the player has or any other sort of variable you use in your game and want to persist every time the player saves the game.
Monogatari has a built-in storage object where you can and should place all the variables you'll use and want to save. There's already a declaration made for you in the storage.js file. We recommend you keep your storage in that file since it's easier to keep track of all your variables and also means you only have to update that one when you add, remove or update any of them.
By default, the storage looks something like this:
1
monogatari.storage ({
2
	player: {
3
		name: ''
4
	}
5
});
Copied!
Adding more variables
The storage is a simple JSON object, meaning we can add as much variables as we want. Let's say we wanted to save the player's age, an important flag for our game and also some stats. We can add some new properties to our storage:
1
monogatari.storage ({
2
	player: {
3
		name: '',
4
		age: 0
5
	},
6
	myFlag: false,
7
	stats: {
8
    hp: 100,
9
    mp: 100,
10
    inventory: {
11
      gold: 1000,
12
      iron: 10
13
    }
14
  }
15
});
Copied!
Notice that the values we provide in this initial declaration will be the default values for these variables.
Updating a value
When something happens in our game and we want to update the value for one of our variables in our storage, we can use the same storage function to do so. Let's say we want to update the player's age:
1
monogatari.storage ({
2
	player: {
3
		age: 18
4
	}
5
});
Copied!
Calling the storage function and providing a new object will not replace the initial one. It will instead take the values we provide and update the storage for us. We can of course update multiple variables in a single call:
1
monogatari.storage ({
2
	player: {
3
		age: 18
4
	},
5
	myFlag: true,
6
	stats: {
7
		hp: 80
8
	}
9
});
Copied!
It is also possible to update a variable by doing a direct assignment:
1
monogatari.storage ().player.age = 18;
Copied!
Retrieving a variable's value
Retrieving the value of a variable once again involves the storage function. Let's say we wanted to retrieve the player's name. All of the following options are valid ways to do so:
1
// Providing the property we want to access
2
const { name } = monogatari.storage ('player');
3
​
4
const name = monogatari.storage ('player').name;
5
​
6
// Not providing any property
7
const { player: { name } } = monogatari.storage ();
8
​
9
const name = monogatari.storage ().player.name;
Copied!
As you can see from that example, it is possible to send the storage function a string, in this case player and it will return us that specific variable which can save us some code. Because of this feature, retrieving a non-nested variable like the myFlag one can be done in these ways:
1
// Providing the property we want to access
2
const flag = monogatari.storage ('myFlag');
3
​
4
// Not providing any property
5
const { myFlag } = monogatari.storage ();
6
​
7
const flag = monogatari.storage ().myFlag;
Copied!
The retrieve, transform and update pattern
Some times, we want to update a variable in a way that the new value is the result of performing an operation over the current value. For example, let's say we wanted to add or substract 20 hp points from the player's stats. 
1
// First, we have to retrieve the current value 
2
// for the hp variable
3
const { hp } = monogatari.storage ('stats');
4
​
5
// Now, we can either substract or add those 20 points.
6
const newHP = hp + 20;
7
​
8
// Finally, we can perform the update
9
monogatari.storage ({
10
	stats: {
11
		hp: newHP
12
	}
13
});
Copied!
For simple transformations as this one, we can actually perform the transformation and update in a single step:
1
// First, we have to retrieve the current value 
2
// for the hp variable
3
const { hp } = monogatari.storage ('stats');
4
​
5
// We add the 20 points and update the value
6
// in a single step
7
monogatari.storage ({
8
	stats: {
9
		hp: hp + 20
10
	}
11
});
Copied!
Data Interpolation
It is possible that we'll want to use the variables in the storage inside a dialog or even in a character's name. Monogatari features some custom string interpolation which you can use by writing a storage variable's key or name inside of two curly braces. 
Let's say you wanted to use the player's name and age in a dialog. Here's what our statement would look like:
1
'Hi {{player.name}}! I can see you\'re {{player.age}} years old.'
Copied!
Notice how you're able to interpolate variables even if they're nested as the player variables are.
Mixing it together
Monogatari has a lot of actions that will let you take advantage of the storage, from inputs and custom functions to dialogs and nice tricks with interpolations. Here's an example of a script using the storage on different actions.
1
monogatari.script ({
2
    'Start': [
3
        {'Input': {
4
            'Text': 'What is your name?',
5
            'Validation': (input) => {
6
                return input.trim().length > 0;
7
            },
8
            'Save': (input) => {
9
                monogatari.storage ({
10
                    player: {
11
                        name: input,
12
                        age: 18
13
                    }
14
                });                                   
15
            },
16
        }},
17
        'Your name is {{player.name}}',
18
        {'Function':{
19
            'Apply': () => {
20
                // We'll overwrite the player's name but save the old one in a new
21
                // value so that we can roll back and restore it if needed.
22
                const { name } = monogatari.storage ('player');
23
                const { hp, inventory: { gold } } = monogatari.storage ('stats');
24
                monogatari.storage ({
25
                    player: {
26
                        name: 'Georg',
27
                    },
28
                    oldName: name,
29
                    stats: {
30
                        hp: hp - 50,
31
                        inventory {
32
                            gold: gold + 250
33
                        }
34
                    }
35
                });
36
            },
37
            'Revert': () => {
38
                // When rolling back, we'll restore the name to what it was before.
39
                const oldName = monogatari.storage ('oldName');
40
                const { hp, inventory: { gold } } = monogatari.storage ('stats');
41
                monogatari.storage ({
42
                    player: {
43
                        name: oldName,
44
                    },
45
                    stats: {
46
                        hp: hp + 50,
47
                        inventory {
48
                            gold: gold - 250
49
                        }
50
                    }
51
                });
52
            }
53
        }},
54
​
55
        '{{player.name}} is {{player_info.age}} years old.',
56
        '{{stats.mp}} costs the ability "Fire Storm".',
57
        '{{stats.inventory.gold}}g is in his bag of gold.',
58
        'end'
59
    ]
60
});
Copied!
Other Resources
Here are some other resources that might be helpful to you regarding the usage of the storage.
A tutorial on how to build a simple stat system using the storage (outdated as it was made for v1.4.1)
​

Building Blocks - Previous

Characters

Next - Building Blocks

Actions

Last modified 1yr ago

Copy link

Contents

Overview

Adding more variables

Updating a value

Retrieving a variable's value

The retrieve, transform and update pattern

Data Interpolation

Mixing it together

Other Resources