Json

Json

SplashKit Json allows you to create and read JSON objects.

Json Guides

Using Json Examples & Guides

Functions

Data Driven Dungeon  {</>}

Demonstrates loading a dungeon level from a JSON file, including parsing arrays of objects for spawn points and loot items.

Return Type: Json

Returns: Returns a json object.

Signatures:

C++

json data_driven_dungeon()

Python

def data_driven_dungeon();

Usage:  {</>}

See Code Examples

Example 1: Data-Driven Dungeon Integration Example

C++

#include "splashkit.h"

int main()
{
    // Load the dungeon room data from the JSON file
    json level_info = json_from_file("level_data.json");

    // Reading top-level strings and integers
    string level_name = json_read_string(level_info, "level_name");
    int difficulty = json_read_number_as_int(level_info, "difficulty");
    string theme = json_read_string(level_info, "theme");

    open_window("Data-Driven Dungeon: " + level_name, 800, 600);

    while (!quit_requested())
    {
        process_events();
        clear_screen(color_black());

        // Display Dungeon metadata
        draw_text("Level: " + level_name, color_white(), 20, 20);
        draw_text("Difficulty: " + std::to_string(difficulty), color_white(), 20, 40);
        draw_text("Theme: " + theme, color_white(), 20, 60);

        // Accessing the 'spawn_points' array and looping through objects
        vector<json> spawn_points;
        json_read_array(level_info, "spawn_points", spawn_points);
        for (int i = 0; i < spawn_points.size(); i++)
        {
            json entry = spawn_points[i];
            string entity_type = json_read_string(entry, "type");
            double x = json_read_number(entry, "x");
            double y = json_read_number(entry, "y");

            color draw_color = (entity_type == "Player") ? color_green() : color_red();
            fill_rectangle(draw_color, x, y, 32, 32);
            draw_text(entity_type, color_white(), x, y - 15);
        }

        // Create loot sprites based on the loot array in the JSON
        vector<json> loot_list;
        json_read_array(level_info, "loot", loot_list);
        for (int i = 0; i < loot_list.size(); i++)
        {
            json item = loot_list[i];
            string item_name = json_read_string(item, "item");
            double x = json_read_number(item, "x");
            double y = json_read_number(item, "y");

            fill_circle(color_gold(), x, y, 8);
            draw_text(item_name, color_gold(), x - 20, y - 20);
        }

        refresh_screen(60);
    }

    // Clean up
    free_json(level_info);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Data-Driven dungeon loading logic
Json levelInfo = JsonFromFile("level_data.json");

// Access strings and ints
string levelName = JsonReadString(levelInfo, "level_name");
int difficulty = JsonReadInteger(levelInfo, "difficulty");
string theme = JsonReadString(levelInfo, "theme");

OpenWindow($"Dungeon: {levelName}", 800, 600);

while (!QuitRequested())
{
    ProcessEvents();
    ClearScreen(ColorBlack());

    DrawText($"Level Name: {levelName}", ColorWhite(), 20, 20);
    DrawText($"Difficulty: {difficulty}", ColorWhite(), 20, 40);
    DrawText($"Theme: {theme}", ColorWhite(), 20, 60);

    // Reading nested objects from an array
    Json spawnPoints = JsonReadArray(levelInfo, "spawn_points");
    for (int i = 0; i < JsonArraySize(spawnPoints); i++)
    {
        Json entry = JsonReadObjectAtIndex(spawnPoints, i);
        string type = JsonReadString(entry, "type");
        double x = JsonReadNumber(entry, "x");
        double y = JsonReadNumber(entry, "y");

        Color drawColor = (type == "Player") ? ColorGreen() : ColorRed();
        FillRectangle(drawColor, x, y, 32, 32);
        DrawText(type, ColorWhite(), (float)x, (float)y - 15);
    }

    // Reading loot points
    Json lootItems = JsonReadArray(levelInfo, "loot");
    for (int i = 0; i < JsonArraySize(lootItems); i++)
    {
        Json item = JsonReadObjectAtIndex(lootItems, i);
        string itemName = JsonReadString(item, "item");
        double x = JsonReadNumber(item, "x");
        double y = JsonReadNumber(item, "y");

        FillCircle(ColorGold(), (float)x, (float)y, 8);
        DrawText(itemName, ColorGold(), (float)x - 20, (float)y - 20);
    }

    RefreshScreen(60);
}

FreeJson(levelInfo);
CloseAllWindows();

Object-Oriented

using System;
using SplashKitSDK;
using static SplashKitSDK.SplashKit;

namespace DataDrivenDungeon
{
    public class DungeonManager
    {
        private Json _levelData;

        public DungeonManager(string fileName)
        {
            _levelData = JsonFromFile(fileName);
        }

        public string LevelName => JsonReadString(_levelData, "level_name");
        public int Difficulty => JsonReadInteger(_levelData, "difficulty");
        public string Theme => JsonReadString(_levelData, "theme");

        public void Draw()
        {
            ClearScreen(ColorBlack());
            DrawText($"Level: {LevelName}", ColorWhite(), 20, 20);
            DrawText($"Difficulty: {Difficulty}", ColorWhite(), 20, 40);
            DrawText($"Theme: {Theme}", ColorWhite(), 20, 60);

            // Accessing the 'spawn_points' array and looping through objects
            Json spawnPoints = JsonReadArray(_levelData, "spawn_points");
            for (int i = 0; i < JsonArraySize(spawnPoints); i++)
            {
                Json entry = JsonReadObjectAtIndex(spawnPoints, i);
                string entryType = JsonReadString(entry, "type");
                double x = JsonReadNumber(entry, "x");
                double y = JsonReadNumber(entry, "y");

                Color drawColor = (entryType == "Player") ? ColorGreen() : ColorRed();
                FillRectangle(drawColor, x, y, 32, 32);
                DrawText(entryType, ColorWhite(), (float)x, (float)y - 15);
            }

            // Accessing the 'loot' array
            Json lootPoints = JsonReadArray(_levelData, "loot");
            for (int i = 0; i < JsonArraySize(lootPoints); i++)
            {
                Json item = JsonReadObjectAtIndex(lootPoints, i);
                string lootName = JsonReadString(item, "item");
                double x = JsonReadNumber(item, "x");
                double y = JsonReadNumber(item, "y");

                FillCircle(ColorGold(), (float)x, (float)y, 8);
                DrawText(lootName, ColorGold(), (float)x - 20, (float)y - 20);
            }
        }

        public void Cleanup()
        {
            FreeJson(_levelData);
        }
    }

    public class Program
    {
        public static void Main()
        {
            DungeonManager dungeon = new DungeonManager("level_data.json");
            OpenWindow($"Dungeon Navigator: {dungeon.LevelName}", 800, 600);

            while (!QuitRequested())
            {
                ProcessEvents();
                dungeon.Draw();
                RefreshScreen(60);
            }

            dungeon.Cleanup();
            CloseAllWindows();
        }
    }
}

Python

from splashkit import *

def main():
    # Load the JSON file
    level_info = json_from_file("level_data.json")

    # Read basic data fields
    level_name = json_read_string(level_info, "level_name")
    difficulty = json_read_integer(level_info, "difficulty")
    theme = json_read_string(level_info, "theme")

    open_window(f"Data-Driven Dungeon: {level_name}", 800, 600)

    while not quit_requested():
        process_events()
        clear_screen(color_black())

        # Display metadata on screen
        draw_text(f"Level Name: {level_name}", color_white(), 20, 20)
        draw_text(f"Difficulty Score: {difficulty}", color_white(), 20, 40)
        draw_text(f"Dungeon Theme: {theme}", color_white(), 20, 60)

        # Access arrays and objects nested inside the JSON
        spawn_points = json_read_array(level_info, "spawn_points")
        for i in range(json_array_size(spawn_points)):
            entry = json_read_object_at_index(spawn_points, i)
            entity_type = json_read_string(entry, "type")
            x = json_read_number(entry, "x")
            y = json_read_number(entry, "y")

            draw_color = color_green() if entity_type == "Player" else color_red()
            fill_rectangle(draw_color, x, y, 32, 32)
            draw_text(entity_type, color_white(), x, y - 15)

        # Iterate through loot array
        loot_items = json_read_array(level_info, "loot")
        for i in range(json_array_size(loot_items)):
            item = json_read_object_at_index(loot_items, i)
            item_name = json_read_string(item, "item")
            x = json_read_number(item, "x")
            y = json_read_number(item, "y")

            fill_circle(color_gold(), x, y, 8)
            draw_text(item_name, color_gold(), x - 20, y - 20)

        refresh_screen_with_target_fps(60)

    # Note: free_json(level_info) is implicitly handled in splashkit-python wrapper but explicit cleanup is good practice
    close_all_windows()

if __name__ == "__main__":
    main()

Output:

---

Create Json  {</>}

Note

This function is overloaded. The following versions exist:

• Create Json ()  {</>}
• Create Json (json_string: string)

Create Json  {</>}

The empty Json object returned can be filled with data and read by the functions and procedures prefixed with json_add_ and json_read_

Return Type: Json

Returns: Returns an empty Json object.

Signatures:

C++

json create_json()

C#

public static Json SplashKit.CreateJson();
public Json();

Python

def create_json():

Pascal

function CreateJson(): Json

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit
• How to make a RESTful API call using SplashKit

API Documentation Code Examples:

• Json Has Key: Json Has Key

---

Create Json

string json_string must be valid JSON. The Json object returned can be filled with data and read by the functions and procedures prefixed with json_add_ and json_read_

Parameters:

Name	Type	Description
json_string	String	The JSON formatted String to be converted to a Json object.

Return Type: Json

Returns: Returns a Json object filled with data from the parameter String.

Signatures:

C++

json create_json(string json_string)

C#

public static Json SplashKit.CreateJson(string jsonString);
public Json(string jsonString);

Python

def create_json_from_string(json_string):

Pascal

function CreateJson(jsonString: String): Json

---

Free All Json  {</>}

Releases all of the Json objects which have been loaded.

Signatures:

C++

void free_all_json()

C#

public static void Json.FreeAll();
public static void SplashKit.FreeAllJson();

Python

def free_all_json():

Pascal

procedure FreeAllJson()

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

API Documentation Code Examples:

• Json Read Array: Score Board

---

Free Json  {</>}

Frees the SplashKit resources associated with the Json object.

Parameters:

Name	Type	Description
j	Json	The Json object whose resources should be released.

Signatures:

C++

void free_json(json j)

C#

public void Json.Free();
public static void SplashKit.FreeJson(Json j);

Python

def free_json(j):

Pascal

procedure FreeJson(j: Json)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

API Documentation Code Examples:

• Data Driven Dungeon: Data-Driven Dungeon Integration Example
• Json Has Key: Json Has Key
• Json Read Array: Badge Board
• Json Read Array: Temperature Log

---

Json Count Keys

Returns the count of keys in the top-level Json object.

Parameters:

Name	Type	Description
j	Json	The Json object to count keys.

Return Type: Integer

Returns: The count of keys in the top-level Json object.

Signatures:

C++

int json_count_keys(json j)

C#

public int Json.CountKeys();
public static int SplashKit.JsonCountKeys(Json j);

Python

def json_count_keys(j):

Pascal

function JsonCountKeys(j: Json): Integer

---

Json From Color

Converts a Color to a Json object.

Parameters:

Name	Type	Description
clr	Color	The Color to convert to Json.

Return Type: Json

Returns: The Color serialized into a Json object.

Signatures:

C++

json json_from_color(color clr)

C#

public static Json SplashKit.JsonFromColor(Color clr);

Python

def json_from_color(clr):

Pascal

function JsonFromColor(clr: Color): Json

---

Json From File  {</>}

Reads a Json object from a JSON string stored in Resources/json/filename and loads the data into the returned Json object.

Parameters:

Name	Type	Description
filename	String	The filename of the file to be written to Resources/json/.

Return Type: Json

Returns: Returns the Json object loaded from the JSON file in filename.

Signatures:

C++

json json_from_file(const string &filename)

C#

public static Json Json.FromFile(string filename);
public static Json SplashKit.JsonFromFile(string filename);

Python

def json_from_file(filename):

Pascal

function JsonFromFile(const filename: String): Json

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit
• Using JSON in SplashKit

API Documentation Code Examples:

• Data Driven Dungeon: Data-Driven Dungeon Integration Example

---

Json From String  {</>}

Reads a Json object from a String in the JSON format.

Parameters:

Name	Type	Description
j_string	String	A String in the JSON format.

Return Type: Json

Returns: Returns a Json object loaded with data from string j_string.

Signatures:

C++

json json_from_string(const string &j_string)

C#

public static Json Json.FromJsonString(string jString);
public static Json SplashKit.JsonFromString(string jString);

Python

def json_from_string(j_string):

Pascal

function JsonFromString(const jString: String): Json

Usage:  {</>}

See Implementations

Tutorials and Guides:

• How to make a RESTful API call using SplashKit
• How to make a RESTful API call using SplashKit

API Documentation Code Examples:

• Json Read Array: Badge Board
• Json Read Array: Temperature Log
• Json Read Array: Score Board
• Json Read Array: Fruit Basket

---

Json Has Key  {</>}

Checks if the Json object contains the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object to check for the given key.
key	String	The String key to be checked.

Return Type: Boolean

Returns: Returns true if the json j object contains a key for String key.

Signatures:

C++

bool json_has_key(json j, string key)

C#

public bool Json.HasKey(string key);
public static bool SplashKit.JsonHasKey(Json j, string key);

Python

def json_has_key(j, key):

Pascal

function JsonHasKey(j: Json; key: String): Boolean

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

See Code Examples

Example 1: Json Has Key

C++

#include "splashkit.h"

int main()
{
    json example_json = create_json();

    json_set_string(example_json, "name", "SplashKit");

    bool has_name = json_has_key(example_json, "name");
    bool has_age = json_has_key(example_json, "age");

    write_line("JSON Has Key Example");
    write_line("--------------------");

    if (has_name)
    {
        write_line("Has key 'name': true");
    }
    else
    {
        write_line("Has key 'name': false");
    }

    if (has_age)
    {
        write_line("Has key 'age': true");
    }
    else
    {
        write_line("Has key 'age': false");
    }

    free_json(example_json);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Json exampleJson = CreateJson();

JsonSetString(exampleJson, "name", "SplashKit");

bool hasName = JsonHasKey(exampleJson, "name");
bool hasAge = JsonHasKey(exampleJson, "age");

WriteLine("JSON Has Key Example");
WriteLine("--------------------");

if (hasName)
{
    WriteLine("Has key 'name': true");
}
else
{
    WriteLine("Has key 'name': false");
}

if (hasAge)
{
    WriteLine("Has key 'age': true");
}
else
{
    WriteLine("Has key 'age': false");
}

FreeJson(exampleJson);

Object-Oriented

using SplashKitSDK;

namespace JsonHasKeyExample
{
    public class Program
    {
        public static void Main()
        {
            Json exampleJson = SplashKit.CreateJson();

            SplashKit.JsonSetString(exampleJson, "name", "SplashKit");

            bool hasName = SplashKit.JsonHasKey(exampleJson, "name");
            bool hasAge = SplashKit.JsonHasKey(exampleJson, "age");

            SplashKit.WriteLine("JSON Has Key Example");
            SplashKit.WriteLine("--------------------");

            if (hasName)
            {
                SplashKit.WriteLine("Has key 'name': true");
            }
            else
            {
                SplashKit.WriteLine("Has key 'name': false");
            }

            if (hasAge)
            {
                SplashKit.WriteLine("Has key 'age': true");
            }
            else
            {
                SplashKit.WriteLine("Has key 'age': false");
            }

            SplashKit.FreeJson(exampleJson);
        }
    }
}

Python

from splashkit import *

example_json = create_json()

json_set_string(example_json, "name", "SplashKit")

has_name = json_has_key(example_json, "name")
has_age = json_has_key(example_json, "age")

write_line("JSON Has Key Example")
write_line("--------------------")

if has_name:
    write_line("Has key 'name': true")
else:
    write_line("Has key 'name': false")

if has_age:
    write_line("Has key 'age': true")
else:
    write_line("Has key 'age': false")

free_json(example_json)

Output:

---

Json Read Array  {</>}

Note

This function is overloaded. The following versions exist:

• Json Read Array (j: json, key: string, out_result: vector)  {</>}
• Json Read Array (j: json, key: string, out_result: vector)  {</>}
• Json Read Array (j: json, key: string, out_result: vector)  {</>}
• Json Read Array (j: json, key: string, out_result: vector)  {</>}

Json Read Array  {</>}

Reads an array of Double values from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.
out_result	Vector	The array which will be filled with the data stored for String key.

Signatures:

C++

void json_read_array(json j, string key, vector<double> &out_result)

C#

public void Json.ReadArray(string key, ref List<double> outResult);
public static void SplashKit.JsonReadArray(Json j, string key, ref List<double> outResult);

Python

def json_read_array_of_double(j, key, out_result):

Pascal

procedure JsonReadArray(j: Json; key: String; var outResult: ArrayOfDouble)

Usage:  {</>}

See Code Examples

Example 1: Temperature Log

C++

#include "splashkit.h"

int main()
{
    // Build the Json from text, so the example needs no resource files
    json weather = json_from_string("{\"temperatures\": [18.5, 21.5, 19.5, 22.5]}");

    // The function fills a list that we create empty first
    vector<double> temperatures;
    json_read_array(weather, "temperatures", temperatures);

    // The readings never change, so add them up once instead of every frame
    int temperature_count = temperatures.size();
    double total = 0;

    for (int index = 0; index < temperature_count; index++)
    {
        total += temperatures[index];
    }

    double average = total / temperature_count;

    open_window("Temperature Log", 520, 360);

    while (!quit_requested())
    {
        process_events();
        clear_screen(COLOR_WHITE);

        draw_text("Recent temperatures", COLOR_BLACK, "arial", 30, 30, 25);

        for (int index = 0; index < temperature_count; index++)
        {
            draw_text("Day " + std::to_string(index + 1) + ": " + to_string(temperatures[index], 1) + " C", COLOR_BLACK, "arial", 24, 30, 85 + index * 40);
        }

        draw_text("Average: " + to_string(average, 1) + " C", COLOR_BLACK, "arial", 26, 30, 270);

        refresh_screen(60);
    }

    free_json(weather);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Build the Json from text, so the example needs no resource files
Json weather = JsonFromString("{\"temperatures\": [18.5, 21.5, 19.5, 22.5]}");

// The function fills a list that we create empty first
List<double> temperatures = new List<double>();
JsonReadArray(weather, "temperatures", ref temperatures);

// The readings never change, so add them up once instead of every frame
int temperatureCount = temperatures.Count;
double total = 0;

for (int index = 0; index < temperatureCount; index++)
{
    total += temperatures[index];
}

double average = total / temperatureCount;

OpenWindow("Temperature Log", 520, 360);

while (!QuitRequested())
{
    ProcessEvents();
    ClearScreen(ColorWhite());

    DrawText("Recent temperatures", ColorBlack(), "arial", 30, 30, 25);

    for (int index = 0; index < temperatureCount; index++)
    {
        DrawText($"Day {index + 1}: {temperatures[index]} C", ColorBlack(), "arial", 24, 30, 85 + index * 40);
    }

    DrawText($"Average: {average} C", ColorBlack(), "arial", 26, 30, 270);

    RefreshScreen(60);
}

FreeJson(weather);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace JsonReadArrayOfDoubleExample
{
    public class Program
    {
        public static void Main()
        {
            // Build the Json from text, so the example needs no resource files
            Json weather = SplashKit.JsonFromString("{\"temperatures\": [18.5, 21.5, 19.5, 22.5]}");

            // The function fills a list that we create empty first
            List<double> temperatures = new List<double>();
            SplashKit.JsonReadArray(weather, "temperatures", ref temperatures);

            // The readings never change, so add them up once instead of every frame
            int temperatureCount = temperatures.Count;
            double total = 0;

            for (int index = 0; index < temperatureCount; index++)
            {
                total += temperatures[index];
            }

            double average = total / temperatureCount;

            SplashKit.OpenWindow("Temperature Log", 520, 360);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();
                SplashKit.ClearScreen(Color.White);

                SplashKit.DrawText("Recent temperatures", Color.Black, "arial", 30, 30, 25);

                for (int index = 0; index < temperatureCount; index++)
                {
                    SplashKit.DrawText($"Day {index + 1}: {temperatures[index]} C", Color.Black, "arial", 24, 30, 85 + index * 40);
                }

                SplashKit.DrawText($"Average: {average} C", Color.Black, "arial", 26, 30, 270);

                SplashKit.RefreshScreen(60);
            }

            weather.Free();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Build the Json from text, so the example needs no resource files
weather = json_from_string('{"temperatures": [18.5, 21.5, 19.5, 22.5]}')

# The function fills a list that we create empty first
temperatures = []
json_read_array_of_double(weather, "temperatures", temperatures)

# The readings never change, so add them up once instead of every frame
temperature_count = len(temperatures)
total = 0

for index in range(temperature_count):
    total += temperatures[index]

average = total / temperature_count

open_window("Temperature Log", 520, 360)

while not quit_requested():
    process_events()
    clear_screen_to_white()

    draw_text_font_as_string("Recent temperatures", color_black(), "arial", 30, 30, 25)

    for index in range(temperature_count):
        draw_text_font_as_string(f"Day {index + 1}: {temperatures[index]} C", color_black(), "arial", 24, 30, 85 + index * 40)

    draw_text_font_as_string(f"Average: {average} C", color_black(), "arial", 26, 30, 270)

    refresh_screen_with_target_fps(60)

free_json(weather)
close_all_windows()

Output:

---

Json Read Array  {</>}

Reads an array of Json object values from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.
out_result	Vector	The array which will be filled with the data stored for String key.

Signatures:

C++

void json_read_array(json j, string key, vector<json> &out_result)

C#

public void Json.ReadArray(string key, ref List<Json> outResult);
public static void SplashKit.JsonReadArray(Json j, string key, ref List<Json> outResult);

Python

def json_read_array_of_json(j, key, out_result):

Pascal

procedure JsonReadArray(j: Json; key: String; var outResult: ArrayOfJson)

Usage:  {</>}

See Code Examples

Example 1: Score Board

C++

#include "splashkit.h"

int main()
{
    // Build the Json from text, so the example needs no resource files
    json scores = json_from_string("{\"players\": [{\"name\": \"Ada\", \"score\": 120}, {\"name\": \"Grace\", \"score\": 95}, {\"name\": \"Linus\", \"score\": 140}]}");

    // Each entry in this list is a Json object of its own
    vector<json> players;
    json_read_array(scores, "players", players);

    int player_count = players.size();

    open_window("Score Board", 520, 360);

    while (!quit_requested())
    {
        process_events();
        clear_screen(COLOR_WHITE);

        draw_text("Score board", COLOR_BLACK, "arial", 30, 30, 25);

        for (int index = 0; index < player_count; index++)
        {
            // Read the fields from each player like from any other Json object
            string player_name = json_read_string(players[index], "name");
            int player_score = json_read_number_as_int(players[index], "score");

            draw_text(player_name + ": " + std::to_string(player_score), COLOR_BLACK, "arial", 24, 30, 85 + index * 40);
        }

        refresh_screen(60);
    }

    // Frees the scores and the player objects that were read from it
    free_all_json();
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Build the Json from text, so the example needs no resource files
Json scores = JsonFromString("{\"players\": [{\"name\": \"Ada\", \"score\": 120}, {\"name\": \"Grace\", \"score\": 95}, {\"name\": \"Linus\", \"score\": 140}]}");

// Each entry in this list is a Json object of its own
List<Json> players = new List<Json>();
JsonReadArray(scores, "players", ref players);

int playerCount = players.Count;

OpenWindow("Score Board", 520, 360);

while (!QuitRequested())
{
    ProcessEvents();
    ClearScreen(ColorWhite());

    DrawText("Score board", ColorBlack(), "arial", 30, 30, 25);

    for (int index = 0; index < playerCount; index++)
    {
        // Read the fields from each player like from any other Json object
        string playerName = JsonReadString(players[index], "name");
        int playerScore = JsonReadNumberAsInt(players[index], "score");

        DrawText($"{playerName}: {playerScore}", ColorBlack(), "arial", 24, 30, 85 + index * 40);
    }

    RefreshScreen(60);
}

// Frees the scores and the player objects that were read from it
FreeAllJson();
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace JsonReadArrayOfJsonExample
{
    public class Program
    {
        public static void Main()
        {
            // Build the Json from text, so the example needs no resource files
            Json scores = SplashKit.JsonFromString("{\"players\": [{\"name\": \"Ada\", \"score\": 120}, {\"name\": \"Grace\", \"score\": 95}, {\"name\": \"Linus\", \"score\": 140}]}");

            // Each entry in this list is a Json object of its own
            List<Json> players = new List<Json>();
            SplashKit.JsonReadArray(scores, "players", ref players);

            int playerCount = players.Count;

            SplashKit.OpenWindow("Score Board", 520, 360);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();
                SplashKit.ClearScreen(Color.White);

                SplashKit.DrawText("Score board", Color.Black, "arial", 30, 30, 25);

                for (int index = 0; index < playerCount; index++)
                {
                    // Read the fields from each player like from any other Json object
                    string playerName = players[index].ReadString("name");
                    int playerScore = players[index].ReadInteger("score");

                    SplashKit.DrawText($"{playerName}: {playerScore}", Color.Black, "arial", 24, 30, 85 + index * 40);
                }

                SplashKit.RefreshScreen(60);
            }

            // Frees the scores and the player objects that were read from it
            Json.FreeAll();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Build the Json from text, so the example needs no resource files
scores = json_from_string('{"players": [{"name": "Ada", "score": 120}, {"name": "Grace", "score": 95}, {"name": "Linus", "score": 140}]}')

# Each entry in this list is a Json object of its own
players = []
json_read_array_of_json(scores, "players", players)

player_count = len(players)

open_window("Score Board", 520, 360)

while not quit_requested():
    process_events()
    clear_screen_to_white()

    draw_text_font_as_string("Score board", color_black(), "arial", 30, 30, 25)

    for index in range(player_count):
        # Read the fields from each player like from any other Json object
        player_name = json_read_string(players[index], "name")
        player_score = json_read_number_as_int(players[index], "score")

        draw_text_font_as_string(f"{player_name}: {player_score}", color_black(), "arial", 24, 30, 85 + index * 40)

    refresh_screen_with_target_fps(60)

# Frees the scores and the player objects that were read from it
free_all_json()
close_all_windows()

Output:

---

Json Read Array  {</>}

Reads an array of String values from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.
out_result	Vector	The array which will be filled with the data stored for String key.

Signatures:

C++

void json_read_array(json j, string key, vector<string> &out_result)

C#

public void Json.ReadArray(string key, ref List<string> outResult);
public static void SplashKit.JsonReadArray(Json j, string key, ref List<string> outResult);

Python

def json_read_array_of_string(j, key, out_result):

Pascal

procedure JsonReadArray(j: Json; key: String; var outResult: ArrayOfString)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

See Code Examples

Example 1: Fruit Basket

C++

#include "splashkit.h"

int main()
{
    // Build the Json from text, so the example needs no resource files
    json basket = json_from_string("{\"fruits\": [\"apple\", \"banana\", \"cherry\", \"mango\"]}");

    // The function fills a list that we create empty first
    vector<string> fruits;
    json_read_array(basket, "fruits", fruits);

    int fruit_count = fruits.size();

    open_window("Fruit Basket", 520, 360);

    while (!quit_requested())
    {
        process_events();
        clear_screen(COLOR_WHITE);

        draw_text("Fruits in the basket", COLOR_BLACK, "arial", 30, 30, 25);

        for (int index = 0; index < fruit_count; index++)
        {
            draw_text(std::to_string(index + 1) + ". " + fruits[index], COLOR_BLACK, "arial", 24, 30, 85 + index * 40);
        }

        refresh_screen(60);
    }

    free_json(basket);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Build the Json from text, so the example needs no resource files
Json basket = JsonFromString("{\"fruits\": [\"apple\", \"banana\", \"cherry\", \"mango\"]}");

// The function fills a list that we create empty first
List<string> fruits = new List<string>();
JsonReadArray(basket, "fruits", ref fruits);

int fruitCount = fruits.Count;

OpenWindow("Fruit Basket", 520, 360);

while (!QuitRequested())
{
    ProcessEvents();
    ClearScreen(ColorWhite());

    DrawText("Fruits in the basket", ColorBlack(), "arial", 30, 30, 25);

    for (int index = 0; index < fruitCount; index++)
    {
        DrawText($"{index + 1}. {fruits[index]}", ColorBlack(), "arial", 24, 30, 85 + index * 40);
    }

    RefreshScreen(60);
}

FreeJson(basket);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace JsonReadArrayOfStringExample
{
    public class Program
    {
        public static void Main()
        {
            // Build the Json from text, so the example needs no resource files
            Json basket = SplashKit.JsonFromString("{\"fruits\": [\"apple\", \"banana\", \"cherry\", \"mango\"]}");

            // The function fills a list that we create empty first
            List<string> fruits = new List<string>();
            SplashKit.JsonReadArray(basket, "fruits", ref fruits);

            int fruitCount = fruits.Count;

            SplashKit.OpenWindow("Fruit Basket", 520, 360);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();
                SplashKit.ClearScreen(Color.White);

                SplashKit.DrawText("Fruits in the basket", Color.Black, "arial", 30, 30, 25);

                for (int index = 0; index < fruitCount; index++)
                {
                    SplashKit.DrawText($"{index + 1}. {fruits[index]}", Color.Black, "arial", 24, 30, 85 + index * 40);
                }

                SplashKit.RefreshScreen(60);
            }

            basket.Free();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Build the Json from text, so the example needs no resource files
basket = json_from_string('{"fruits": ["apple", "banana", "cherry", "mango"]}')

# The function fills a list that we create empty first
fruits = []
json_read_array_of_string(basket, "fruits", fruits)

fruit_count = len(fruits)

open_window("Fruit Basket", 520, 360)

while not quit_requested():
    process_events()
    clear_screen_to_white()

    draw_text_font_as_string("Fruits in the basket", color_black(), "arial", 30, 30, 25)

    for index in range(fruit_count):
        draw_text_font_as_string(f"{index + 1}. {fruits[index]}", color_black(), "arial", 24, 30, 85 + index * 40)

    refresh_screen_with_target_fps(60)

free_json(basket)
close_all_windows()

Output:

---

Json Read Array  {</>}

Reads an array of Boolean values from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.
out_result	Vector	The array which will be filled with the data stored for String key.

Signatures:

C++

void json_read_array(json j, string key, vector<bool> &out_result)

C#

public void Json.ReadArray(string key, ref List<bool> outResult);
public static void SplashKit.JsonReadArray(Json j, string key, ref List<bool> outResult);

Python

def json_read_array_of_bool(j, key, out_result):

Pascal

procedure JsonReadArray(j: Json; key: String; var outResult: ArrayOfBoolean)

Usage:  {</>}

See Code Examples

Example 1: Badge Board

C++

#include "splashkit.h"

int main()
{
    // Build the Json from text, so the example needs no resource files
    json progress = json_from_string("{\"badges\": [true, false, true, true, false]}");

    // The function fills a list that we create empty first
    vector<bool> badges;
    json_read_array(progress, "badges", badges);

    // Count the unlocked badges once, because the list never changes
    int badge_count = badges.size();
    int unlocked_count = 0;

    for (int index = 0; index < badge_count; index++)
    {
        if (badges[index])
        {
            unlocked_count++;
        }
    }

    open_window("Badge Board", 520, 360);

    while (!quit_requested())
    {
        process_events();
        clear_screen(COLOR_WHITE);

        draw_text("Your badges", COLOR_BLACK, "arial", 30, 30, 25);

        for (int index = 0; index < badge_count; index++)
        {
            if (badges[index])
            {
                draw_text("Badge " + std::to_string(index + 1) + ": unlocked", COLOR_DARK_GREEN, "arial", 24, 30, 85 + index * 40);
            }
            else
            {
                draw_text("Badge " + std::to_string(index + 1) + ": locked", COLOR_GRAY, "arial", 24, 30, 85 + index * 40);
            }
        }

        draw_text("Unlocked: " + std::to_string(unlocked_count) + " of " + std::to_string(badge_count), COLOR_BLACK, "arial", 26, 30, 310);

        refresh_screen(60);
    }

    free_json(progress);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Build the Json from text, so the example needs no resource files
Json progress = JsonFromString("{\"badges\": [true, false, true, true, false]}");

// The function fills a list that we create empty first
List<bool> badges = new List<bool>();
JsonReadArray(progress, "badges", ref badges);

// Count the unlocked badges once, because the list never changes
int badgeCount = badges.Count;
int unlockedCount = 0;

for (int index = 0; index < badgeCount; index++)
{
    if (badges[index])
    {
        unlockedCount++;
    }
}

OpenWindow("Badge Board", 520, 360);

while (!QuitRequested())
{
    ProcessEvents();
    ClearScreen(ColorWhite());

    DrawText("Your badges", ColorBlack(), "arial", 30, 30, 25);

    for (int index = 0; index < badgeCount; index++)
    {
        if (badges[index])
        {
            DrawText($"Badge {index + 1}: unlocked", ColorDarkGreen(), "arial", 24, 30, 85 + index * 40);
        }
        else
        {
            DrawText($"Badge {index + 1}: locked", ColorGray(), "arial", 24, 30, 85 + index * 40);
        }
    }

    DrawText($"Unlocked: {unlockedCount} of {badgeCount}", ColorBlack(), "arial", 26, 30, 310);

    RefreshScreen(60);
}

FreeJson(progress);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace JsonReadArrayOfBoolExample
{
    public class Program
    {
        public static void Main()
        {
            // Build the Json from text, so the example needs no resource files
            Json progress = SplashKit.JsonFromString("{\"badges\": [true, false, true, true, false]}");

            // The function fills a list that we create empty first
            List<bool> badges = new List<bool>();
            SplashKit.JsonReadArray(progress, "badges", ref badges);

            // Count the unlocked badges once, because the list never changes
            int badgeCount = badges.Count;
            int unlockedCount = 0;

            for (int index = 0; index < badgeCount; index++)
            {
                if (badges[index])
                {
                    unlockedCount++;
                }
            }

            SplashKit.OpenWindow("Badge Board", 520, 360);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();
                SplashKit.ClearScreen(Color.White);

                SplashKit.DrawText("Your badges", Color.Black, "arial", 30, 30, 25);

                for (int index = 0; index < badgeCount; index++)
                {
                    if (badges[index])
                    {
                        SplashKit.DrawText($"Badge {index + 1}: unlocked", Color.DarkGreen, "arial", 24, 30, 85 + index * 40);
                    }
                    else
                    {
                        SplashKit.DrawText($"Badge {index + 1}: locked", Color.Gray, "arial", 24, 30, 85 + index * 40);
                    }
                }

                SplashKit.DrawText($"Unlocked: {unlockedCount} of {badgeCount}", Color.Black, "arial", 26, 30, 310);

                SplashKit.RefreshScreen(60);
            }

            progress.Free();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Build the Json from text, so the example needs no resource files
progress = json_from_string('{"badges": [true, false, true, true, false]}')

# The function fills a list that we create empty first
badges = []
json_read_array_of_bool(progress, "badges", badges)

# Count the unlocked badges once, because the list never changes
badge_count = len(badges)
unlocked_count = 0

for index in range(badge_count):
    if badges[index]:
        unlocked_count += 1

open_window("Badge Board", 520, 360)

while not quit_requested():
    process_events()
    clear_screen_to_white()

    draw_text_font_as_string("Your badges", color_black(), "arial", 30, 30, 25)

    for index in range(badge_count):
        if badges[index]:
            draw_text_font_as_string(f"Badge {index + 1}: unlocked", color_dark_green(), "arial", 24, 30, 85 + index * 40)
        else:
            draw_text_font_as_string(f"Badge {index + 1}: locked", color_gray(), "arial", 24, 30, 85 + index * 40)

    draw_text_font_as_string(f"Unlocked: {unlocked_count} of {badge_count}", color_black(), "arial", 26, 30, 310)

    refresh_screen_with_target_fps(60)

free_json(progress)
close_all_windows()

Output:

---

Json Read Bool

Reads a Boolean value from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.

Return Type: Boolean

Returns: Returns the Boolean value stored at the String key.

Signatures:

C++

bool json_read_bool(json j, string key)

C#

public bool Json.ReadBool(string key);
public static bool SplashKit.JsonReadBool(Json j, string key);

Python

def json_read_bool(j, key):

Pascal

function JsonReadBool(j: Json; key: String): Boolean

---

Json Read Number  {</>}

Reads a Float value from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.

Return Type: Float

Returns: Returns the Float value stored at the String key.

Signatures:

C++

float json_read_number(json j, string key)

C#

public float Json.ReadNumber(string key);
public static float SplashKit.JsonReadNumber(Json j, string key);

Python

def json_read_number(j, key):

Pascal

function JsonReadNumber(j: Json; key: String): Single

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Data Driven Dungeon: Data-Driven Dungeon Integration Example

---

Json Read Number As Double

Reads a Double value from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.

Return Type: Double

Returns: Returns the Double value stored at the String key.

Signatures:

C++

double json_read_number_as_double(json j, string key)

C#

public double Json.ReadDouble(string key);
public static double SplashKit.JsonReadNumberAsDouble(Json j, string key);

Python

def json_read_number_as_double(j, key):

Pascal

function JsonReadNumberAsDouble(j: Json; key: String): Double

---

Json Read Number As Int  {</>}

Reads a integer value from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.

Return Type: Integer

Returns: Returns the integer value stored at the String key.

Signatures:

C++

int json_read_number_as_int(json j, string key)

C#

public int Json.ReadInteger(string key);
public static int SplashKit.JsonReadNumberAsInt(Json j, string key);

Python

def json_read_number_as_int(j, key):

Pascal

function JsonReadNumberAsInt(j: Json; key: String): Integer

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit
• Using JSON in SplashKit
• How to make a RESTful API call using SplashKit

API Documentation Code Examples:

• Json Read Array: Score Board

---

Json Read Object  {</>}

Reads a Json object value from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.

Return Type: Json

Returns: Returns the Json object value stored at the String key.

Signatures:

C++

json json_read_object(json j, string key)

C#

public Json Json.ReadObject(string key);
public static Json SplashKit.JsonReadObject(Json j, string key);

Python

def json_read_object(j, key):

Pascal

function JsonReadObject(j: Json; key: String): Json

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit
• Using JSON in SplashKit

---

Json Read String  {</>}

Reads a String value from the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object from which data will be returned for the given key.
key	String	The String key used to find data in the Json object.

Return Type: String

Returns: Returns the String value stored at the String key.

Signatures:

C++

string json_read_string(json j, string key)

C#

public string Json.ReadString(string key);
public static string SplashKit.JsonReadString(Json j, string key);

Python

def json_read_string(j, key):

Pascal

function JsonReadString(j: Json; key: String): String

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit
• How to make a RESTful API call using SplashKit

API Documentation Code Examples:

• Data Driven Dungeon: Data-Driven Dungeon Integration Example
• Json Read Array: Score Board

---

Json Set Array  {</>}

Note

This function is overloaded. The following versions exist:

• Json Set Array (j: json, key: string, value: vector)  {</>}
• Json Set Array (j: json, key: string, value: vector)
• Json Set Array (j: json, key: string, value: vector)
• Json Set Array (j: json, key: string, value: vector)

Json Set Array  {</>}

Adds an array of String values to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Vector	The value to be inserted into the Json object.

Signatures:

C++

void json_set_array(json j, string key, vector<string> value)

C#

public void Json.AddArray(string key, List<string> value);
public static void SplashKit.JsonSetArray(Json j, string key, List<string> value);

Python

def json_set_array_of_string(j, key, value):

Pascal

procedure JsonSetArray(j: Json; key: String; value: ArrayOfString)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

---

Json Set Array

Adds an array of Double values to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Vector	The value to be inserted into the Json object.

Signatures:

C++

void json_set_array(json j, string key, vector<double> value)

C#

public void Json.AddArray(string key, List<double> value);
public static void SplashKit.JsonSetArray(Json j, string key, List<double> value);

Python

def json_set_array_of_double(j, key, value):

Pascal

procedure JsonSetArray(j: Json; key: String; value: ArrayOfDouble)

---

Json Set Array

Adds an array of Boolean values to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Vector	The value to be inserted into the Json object.

Signatures:

C++

void json_set_array(json j, string key, vector<bool> value)

C#

public void Json.AddArray(string key, List<bool> value);
public static void SplashKit.JsonSetArray(Json j, string key, List<bool> value);

Python

def json_set_array_of_bool(j, key, value):

Pascal

procedure JsonSetArray(j: Json; key: String; value: ArrayOfBoolean)

---

Json Set Array

Adds an array of Json object values to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Vector	The value to be inserted into the Json object.

Signatures:

C++

void json_set_array(json j, string key, vector<json> value)

C#

public void Json.AddArray(string key, List<Json> value);
public static void SplashKit.JsonSetArray(Json j, string key, List<Json> value);

Python

def json_set_array_of_json(j, key, value):

Pascal

procedure JsonSetArray(j: Json; key: String; value: ArrayOfJson)

---

Json Set Bool  {</>}

Adds a Boolean value to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Boolean	The value to be inserted into the Json object.

Signatures:

C++

void json_set_bool(json j, string key, bool value)

C#

public void Json.AddBool(string key, bool value);
public static void SplashKit.JsonSetBool(Json j, string key, bool value);

Python

def json_set_bool(j, key, value):

Pascal

procedure JsonSetBool(j: Json; key: String; value: Boolean)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

---

Json Set Number  {</>}

Note

This function is overloaded. The following versions exist:

• Json Set Number (j: json, key: string, value: int)  {</>}
• Json Set Number (j: json, key: string, value: double)
• Json Set Number (j: json, key: string, value: float)

Json Set Number  {</>}

Adds an Integer value to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Integer	The value to be inserted into the Json object.

Signatures:

C++

void json_set_number(json j, string key, int value)

C#

public void Json.AddNumber(string key, int value);
public static void SplashKit.JsonSetNumber(Json j, string key, int value);

Python

def json_set_number_integer(j, key, value):

Pascal

procedure JsonSetNumber(j: Json; key: String; value: Integer)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit
• How to make a RESTful API call using SplashKit

---

Json Set Number

Adds a Double value to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Double	The value to be inserted into the Json object.

Signatures:

C++

void json_set_number(json j, string key, double value)

C#

public void Json.AddNumber(string key, double value);
public static void SplashKit.JsonSetNumber(Json j, string key, double value);

Python

def json_set_number_double(j, key, value):

Pascal

procedure JsonSetNumber(j: Json; key: String; value: Double)

---

Json Set Number

Adds a Float value to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	Float	The value to be inserted into the Json object.

Signatures:

C++

void json_set_number(json j, string key, float value)

C#

public void Json.AddNumber(string key, float value);
public static void SplashKit.JsonSetNumber(Json j, string key, float value);

Python

def json_set_number_float(j, key, value):

Pascal

procedure JsonSetNumber(j: Json; key: String; value: Single)

---

Json Set Object  {</>}

Adds a Json object to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
obj	Json	The value to be inserted into the Json object.

Signatures:

C++

void json_set_object(json j, string key, json obj)

C#

public void Json.AddObject(string key, Json obj);
public static void SplashKit.JsonSetObject(Json j, string key, Json obj);

Python

def json_set_object(j, key, obj):

Pascal

procedure JsonSetObject(j: Json; key: String; obj: Json)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

---

Json Set String  {</>}

Adds a String value to the Json object for the given String key.

Parameters:

Name	Type	Description
j	Json	The Json object where data will be inserted for the given key.
key	String	The String key where data will be stored in the Json object.
value	String	The value to be inserted into the Json object.

Signatures:

C++

void json_set_string(json j, string key, string value)

C#

public void Json.AddString(string key, string value);
public static void SplashKit.JsonSetString(Json j, string key, string value);

Python

def json_set_string(j, key, value):

Pascal

procedure JsonSetString(j: Json; key: String; value: String)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit
• How to make a RESTful API call using SplashKit

API Documentation Code Examples:

• Json Has Key: Json Has Key

---

Json To Color

Converts a Json object to a Color object.

Parameters:

Name	Type	Description
j	Json	The Json to convert to a Color.

Return Type: Color

Returns: The Color deserialized from the Json object.

Signatures:

C++

color json_to_color(json j)

C#

public static Color SplashKit.JsonToColor(Json j);

Python

def json_to_color(j):

Pascal

function JsonToColor(j: Json): Color

---

Json To File  {</>}

Writes the Json object to a JSON string stored in Resources/json/filename.

Parameters:

Name	Type	Description
j	Json	The Json object to be written to file.
filename	String	The filename of the file to be stored in Resources/json/

Signatures:

C++

void json_to_file(json j, const string &filename)

C#

public static void Json.ToFile(Json j, string filename);
public static void SplashKit.JsonToFile(Json j, string filename);

Python

def json_to_file(j, filename):

Pascal

procedure JsonToFile(j: Json; const filename: String)

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using JSON in SplashKit

---

Json To String

Converts and returns the Json object as a String.

Parameters:

Name	Type	Description
j	Json	The Json object to be converted to a String.

Return Type: String

Returns: Returns the Json object as a String.

Signatures:

C++

string json_to_string(json j)

C#

public static string Json.ToJsonString(Json j);
public static string SplashKit.JsonToString(Json j);

Python

def json_to_string(j):

Pascal

function JsonToString(j: Json): String

---

Types

Json

The Json type is used to refer to objects in the JSON format that can be manipulated by the SplashKit Json functions and procedures.

All Json objects are:

• created with create_json() or create_json(string s) or json_from_string(string s) or json_from_file(json j)

• and must be released using free_json() (to release a specific Json object) or free_all_json() (to release all loaded Json objects).

---