Modeling Social Interactions in JSON

1. The Power of Data-Driven Design

Before we write any code, let's talk about the "why". Instead of hard-coding every interaction into our Rust engine (e.g., if interaction == "Joke" { friendship += 5.0; }), we will define them in an external JSON file. This is called data-driven design.

The core idea is to separate the game's logic (the "engine") from its content (the "data").

• Our Rust code is the engine. It knows how to process an interaction and change a relationship score.
• Our JSON file is the data. It defines what interactions exist and what effects they have.

This approach is essential for a moddable game. Adding a new social interaction won't require recompiling the game engine; a modder will just add a new entry to a JSON file.

To see this concept in action in one of the most successful life simulation games, let's watch a segment from Game Maker's Toolkit.

Since you're familiar with Unity, this next video will help bridge the gap. It shows how to implement a data-driven system using Unity's ScriptableObjects, which is conceptually identical to what we'll be doing with Rust and JSON.

2. Designing the Social Interaction Schema

Now, let's design the structure of our interactions.json file. A good data schema is clear, extensible, and contains all the necessary information. For a social interaction, we need:

• id: A unique string to identify the interaction (e.g., "friendly_chat").
• label: The text that will appear in the UI (e.g., "Friendly Chat").
• effects: A list of things that happen when the interaction is executed.

Here is a basic structure for one interaction:

{
  "friendly_chat": {
    "label": "Friendly Chat",
    "effects": [
      {
        "type": "Relationship",
        "score": "Friendship",
        "value": 5.0
      }
    ]
  }
}

This structure is a dictionary (or map) where the key is the interaction id. This allows for fast lookups. The image below shows a similar hierarchical structure in JSON.

For a real-world example of how a popular, moddable game structures its data, let's look at the Stardew Valley modding documentation.

3. Implementing the Rust Data Structures

With our JSON schema designed, let's create the corresponding structs in Rust. Open your Rust project (e.g., in the file where you defined your Character struct) and add the following code.

First, we need an enum to represent which relationship score we're modifying. Using an enum is safer than using a raw string, as the compiler will catch any typos.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// You should already have CharacterId and RelationshipScores from the previous lesson




#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")] // Matches "Friendship", "Romance" in JSON
pub enum RelationshipScoreType {
    Friendship,
    Romance,
}

The #[serde(rename_all = "PascalCase")] attribute tells serde to expect the enum variants in PascalCase in the JSON file, which is a common convention.

Next, let's define the structure for an effect. For now, we only have one type of effect, but this design makes it easy to add more later (e.g., for changing Needs).

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(tag = "type")] // Expects a "type" field to distinguish enum variants
pub enum InteractionEffect {
    Relationship(RelationshipEffect),
    // We could add other effects here later, e.g., Need(NeedEffect)
}




#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RelationshipEffect {
    pub score: RelationshipScoreType,
    pub value: f32,
}

Here, #[serde(tag = "type")] is a powerful feature. It means that when serde deserializes the JSON for InteractionEffect, it will look for a field named "type" (like "type": "Relationship") to decide which variant of the enum to create.

Finally, we define the main SocialInteraction struct that ties everything together.

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct SocialInteraction {
    pub label: String,
    pub effects: Vec<InteractionEffect>,
}

4. Creating the Interaction Data File

Now you can create the actual data file. In the root of your Rust project, create a new file named interactions.json. Paste the following content into it. This will be our starting set of social interactions.

{
  "friendly_chat": {
    "label": "Friendly Chat",
    "effects": [
      {
        "type": "Relationship",
        "score": "Friendship",
        "value": 5.0
      }
    ]
  },
  "tell_joke": {
    "label": "Tell Joke",
    "effects": [
      {
        "type": "Relationship",
        "score": "Friendship",
        "value": 8.0
      },
      {
        "type": "Relationship",
        "score": "Romance",
        "value": 2.0
      }
    ]
  },
  "flirt": {
    "label": "Flirt",
    "effects": [
      {
        "type": "Relationship",
        "score": "Friendship",
        "value": 1.0
      },
      {
        "type": "Relationship",
        "score": "Romance",
        "value": 10.0
      }
    ]
  },
  "insult": {
    "label": "Insult",
    "effects": [
      {
        "type": "Relationship",
        "score": "Friendship",
        "value": -15.0
      },
      {
        "type": "Relationship",
        "score": "Romance",
        "value": -10.0
      }
    ]
  }
}

Notice how "Tell Joke" affects both friendship and romance slightly, while "Insult" has a strong negative impact. This data-driven approach allows for nuanced design that you can easily tweak later.

This hierarchical structure of defining interactions, effects, and rules is also a topic of academic research in procedural narrative and AI.

Conclusion

Great job! You have now defined the "content" of your social system. By creating a clear JSON schema and corresponding Rust structs, you've built a flexible, data-driven framework for social interactions.

Key Takeaways:

• Data-Driven Design: You learned why separating logic (Rust) from content (JSON) is crucial for creating a flexible and moddable game.
• JSON Schema Design: You designed a hierarchical JSON structure to represent social interactions, their UI labels, and their effects on the simulation.
• Rust Struct Mapping: You implemented a set of Rust structs and enums with serde attributes that precisely mirror your JSON schema, enabling easy serialization and deserialization.
• Real-World Parallels: You saw how successful games like The Sims and Stardew Valley use these same data-driven principles.

In our next lesson, we will complete the loop. We will implement the logic in Rust to update relationship scores based on the outcome of these social interactions, and we'll take the first step in making the simulation even more dynamic by having character personality traits modify those outcomes.