Kudzu Game Engine

The Kudzu Engine is a student project where, together with 15 teammates, we developed a game inside our custom game engine for both PS5 and PC. The project consisted of 2 parts.

The second stage, Block D, we were allowed to take our engine with us and use it to make a game. We got 4 artists and 3 designers, and a couple gameplay programmers to help us make a game.

My Contributions

• 📝 Scripting: A custom scripting language that allows for quick iterations of game logic. All gameplay logic is written in language.
• 📦 Prefabs / Serialization: Allowing users to make reusable objects that can be used in multiple scenes and be easily updated.
• 🔧 Editor Tools: Developing tools within the editor to improve the workflow for designers and artists.
• 🏭 CI / CD: A Jenkins pipeline that will automatically “ship” the engine to the team whenever someone changes the engine code.
• 👥 User Experience: Making sure the editor is user-friendly and usable by artists, designers, and programmers. Focusing on their needs and feedback.
• 🏗️ Engine architecture: Designing the engine is such a way where it is easy to extend and maintain. Making sure the engine is scalable and can handle larger projects.

Below I will go over some of these features in more detail.

📝 Scripting

All gameplay logic is written in a custom scripting language. Gameplay programmers and designers to can write the gameplay code without having to recompile any C++ code. This allows for quick iterations and testing of game logic.

The scripting language give us a clear separation between the engine and the game logic. Additionally, it makes the engine “shippable”, scripts are loaded at runtime. Anyone with the engine executable can write scripts and make a game with it. No need to have the engine source code or compile it.

📦 Prefabs / Serialization

Problem: Teams faced bottlenecks when multiple developers needed the same entities across scenes. Scene files became locked in version control, preventing others from working, and recreating identical entities manually was inefficient and error-prone.

Solution: I developed a prefab system that serializes entities and components into reusable files. Designers can place prefabs in any scene and customize parameters locally, while programmers can update the base prefab to automatically propagate changes across all instances. This solved version control conflicts and enabled everyone to work independently.

Creating a Prefab and changing it

Prefab Structure - levels/scenes reference the prefab file.

- Entity "Player"
    - Transform
        - Position
            - 0,0,0
        - Rotation
            - 0,0,0,0
        - Scale
            - 1,1,1
    - Script
        - Path
            - "Assets/Scripts/PlayerScript.as"
        - Properties
            - Health
                - 100
            - Speed
                - 10
- Entity "John Doe"
...

- Entity "Ball"
    - Transform
        - Position
            - 0,0,0
        - Rotation
            - 0,0,0,0
        - Scale
            - 1,1,1
    - Mesh
        - Path
            - "Assets/Models/Ball.obj"
        - Color
            - 1,0,0

- Entity "Player"
... (same as before, not important)
- Entity "John Doe"
...
- Entity "Ball"
    - Transform
        - Position
            - 0,0,0
        - Rotation
            - 0,0,0,0
        - Scale
            - 1,1,1
    - Mesh
        - Path
            - "Assets/Models/Ball.obj"
        - Color
            - 1,0,0

- Entity "Player"
... (same as before, not important)
- Entity "John Doe"
...
- Entity "Ball"
    - Prefab
        - Path
            - "Assets/Prefabs/Ball.prefab"

- Entity 1
...
- Entity 2
...
- Entity 3
    - Prefab
        - Path
            - "Assets/Prefabs/Ball.prefab"
        - Overrides
            - Transform
                - Scale
                    - 2,2,2

struct MyStruct {
    int a = 0;
    float b = 0.0f;
    std::string c = "default";
};

VISITABLE_STRUCT(MyStruct, a, b, c);

static inline svh::json SerializeImpl(const MyStruct& s) {
    svh::json result = svh::json::object();
    result["a"] = svh::Serializer::Serialize(s.a); // int
    result["b"] = svh::Serializer::Serialize(s.b); // float
    result["c"] = svh::Serializer::Serialize(s.c); // string
    return result;
}

static inline void DeserializeImpl(const svh::json& j, MyStruct& s) {
    if (j.is_object()) {
        svh::Deserializer::FromJson(j["a"], s.a); // int
        svh::Deserializer::FromJson(j["b"], s.b); // float
        svh::Deserializer::FromJson(j["c"], s.c); // string
    }
}

/* Serializer function detection */
template <typename T>
using serialize_fn = decltype(SerializeImpl(std::declval<const T&>()));

template <typename T>
constexpr bool has_serialize_v = is_detected<serialize_fn, T>::value;

template <typename T, typename R>
using enable_if_has_serialize = std::enable_if_t<has_serialize_v<T>, R>;

/* Has std::begin/std::end */
template <class, class = void>
struct has_begin_end : std::false_type {};

template <class T>
struct has_begin_end<T, std::void_t<decltype(std::begin(std::declval<T&>())), decltype(std::end(std::declval<T&>()))>> : std::true_type {};

template <class T>
constexpr bool has_begin_end_v = has_begin_end<T>::value;

template <class T, class R = void>
using enable_if_has_begin_end = std::enable_if_t<has_begin_end_v<T>, R>;

/* Generic container for vector, array, set, unordered_set, multiset, unordered_multiset, deque, list, foward_list, initializer_lists */
template<class T>
static inline auto SerializeImpl(const T& c) -> svh::enable_if_has_begin_end<T, svh::json> {
    svh::json result = svh::json::array();
    for (auto const& item : c) {
        result.push_back(svh::Serializer::ToJson(item));
    }
    return result;
}

Transform A;
A.position = { 1.0f, 2.0f, 3.0f };
A.rotation = { 1.0f, 0.0f, 0.0f, 0.0f };
A.scale = { 1.0f, 1.0f, 1.0f };

Transform B;
B.position = { 4.0f, 5.0f, 6.0f };
B.rotation = { 1.0f, 0.0f, 0.0f, 0.0f }; // rotation unchanged
B.scale = { 11.0f, 12.0f, 13.0f };

svh::json changes = svh::Compare::GetChanges(A, B);

{"position":[4.0,5.0,6.0],"scale":[11.0,12.0,13.0]}

std::vector<int> left{ 1,2,3 };
std::vector<int> right{ 1,2,3 };

{}

std::vector<int> left{ 1,2,3 };
std::vector<int> right{ 1,2,3,4 };

{"added":[{"index":[3],"value":4}]}

std::vector<int> left{ 1,2,3,4 };
std::vector<int> right{ 1,2,3 };

{"removed":[[3]]}

std::vector<int> left{ 1,2,3 };
std::vector<int> right{ 4,5,6 };

{"changed":[{"index":[0],"value":4},{"index":[1],"value":5},{"index":[2],"value":6}]}

template<typename T>
struct CustomCompare {
    bool impl(const T& a, const T& b) const {
        auto changes = svh::Compare::GetChanges(a, b);
        return changes.empty();
    }
};

template<typename Elem>
static inline svh::json CompareImpl(const std::vector<Elem>& left, const std::vector<Elem>& right) {
    // Use the custom comparator to compare elements
    dtl::Diff<Elem, std::vector<Elem>, CustomCompare<Elem>> d(left, right, false, CustomCompare<Elem>{});
    d.compose();
    auto ses = d.getSes();

    // ses now contains the changes like added, removed, and changed
    // ...
}

🏭 CI / CD

Problem:

• Designers and artists only know how to use Perforce.
• “Ship” the latest engine build to the designers, artists, and gameplay programmers.
• Compiling the engine yourself and uploading it to Perforce is cumbersome and time-consuming.

Solution: Develop a Jenkins pipeline to automate the build process.

Now that we have actual people working inside the engine, there is bound to be bugs/oversights. We need a way to quickly fix these and prevent blocking the workflow of the designers and artists.

At first, we compiled the engine ourselves and uploaded it to Perforce. This was slow and took a way time from programmers. To solve this, I set up a Jenkins pipeline that triggers whenever we push code to the main branch. The pipeline gets the latest code, compiles the engine, and uploads the executable to Perforce.

This made it super simple and quick of us to develop/fix the engine. On average, the pipeline ran 5–6 times a day. If someone had to do this by hand, it would have taken a lot of time and effort every day.

DRY - “Don’t Repeat Yourself”

~ Andy Hunt and Dave Thomas

Jenkins Pipeline visualization

👥 User Experience / Collaboration

A big part of my role was to improve user experience. Making sure the engine is intuitive, user-friendly, usable, and clear for the designers, artists and gameplay programmers. This meant I had to work closely with the designers and artists to understand their needs and how they work. Iterating on the engine/features based on their feedback and suggestions.

I appreciate when we have a feature request, you’re good at asking further questions. Like “How do you want it”, “How should it work”. You’re keeping us up to date and asking if this is how we want it.

Simon, designer from my team

Below are some of the features I implemented based on feedback from the designers and artists. While these features might be small, they make a big difference in the user experience and gave the designers and artists a better workflow.

Copy / Paste

Being able to copy/paste/duplicate is super nice to have. This gives users the ability to quickly duplicate entities in the scene without having to create them from scratch. This allows for faster iteration and prototyping.

I implemented so you can copy/paste almost anything. Including entities, components, properties, etc.

Drag & Drop

This was a feature that was requested by the designers. They wanted to be able to drag and drop assets from the asset browser into the scene. This is a common feature in many game engines, but it was missing in our engine.

I implemented this by sending a ray from the camera to the scene. If it hits something, it places the asset at that position, if it doesn’t hit anything, it places the object at a certain distance that you can change by dragging the mouse up and down.

Undo / Redo

Being able to undo and redo actions in the editor is crucial for a good user experience. It allows users to quickly fix mistakes and try out different things without having to worry about losing their work.

Pressing Ctrl + Z will undo the last action, and pressing Ctrl + Y OR Ctrl + Shift + Z will redo the last undone action.

template <typename T>
class DiffUtil : public IDiffOperation {
    public:
    DiffUtil() = default;

    void take_snapshot(T* value) {
        target = value;
        m_snapshot_before = JsonSerializer::serialize(*value);
    }

    void commit_changes(const std::string commit_message) {
        m_snapshot_after = JsonSerializer::serialize(*target);

        auto op = std::make_shared<DiffUtil<T>>(*this);
        Engine.undo_redo_manager().add_operation(op, commit_message);
    };

    virtual void undo() override {
        if (target) {
            JsonDeserializer::deserialize(m_snapshot_before, *target);
        }
    };

    virtual void redo() override {
        if (target) {
            JsonDeserializer::deserialize(m_snapshot_after, *target);
        }
    };

    private:
    svh::json m_snapshot_before;
    svh::json m_snapshot_after;
    T* target;
};

Transform& t = Engine.ecs().registry.get<Transform>(entity); // get the transform of the entity
glm::vec3 translation(t.GetTranslation()); // make a copy of the translation
if (DragFloat3("Position", translation, 0.01f)) { // Detect if the user changed the translation
    DiffUtil<Transform> diff_util;
    diff_util.take_snapshot(&t); // take a snapshot of the original transform

    t.SetTranslation(translation); // set the new translation

    diff_util.commit_changes("Set Translation"); // commit the changes
}

Pop-ups

Pop-ups are a great way to give feedback to the user. They can be used to show errors, warnings, or just information. I implemented a simple pop-up system that allows you to create pop-ups with a title, message, and buttons with actions.

See ▶ Read More for more information on how the pop-up system works.

PopUp::create()
    .title("Remove Component")
    .message("Removing a component on a prefab is not possible.")
    .option("OK");

PopUp::create()
    .title("Question")
    .message("Did you like the previous pop-up?")
    .has_close(false) // Don't show the X in the top right corner
    .option("Yes")
    .option("Maybe")
    .option("No", []() {
        // Do something
        Engine.window().request_close(); // Close the engine :)
    });

Zentera - The Game

As said before, after the first 8 weeks of developing the engine, we had another 8 weeks to make a game with the engine. We were joined by another 8 teammates, including artists, designers, and gameplay programmers.

We made a game called Zentera. A 3D voxel-based puzzle platformer where you play as a lizard that uses his tongue to interact with the environment. The game was made for both PC and PS5.

Note, all gameplay is made using the scripting language I developed

🗂️ Open Source

We decided to open source the game/engine. This meant everybody had access to the engine, tools, source code, and assets that were used to create Zentera. Allowing anyone to modify the game. They could:

• 🌄 Create New Levels - Design fresh maps, puzzles, and challenges, or modify existing ones to enhance gameplay.
• 🛠 Change the code - Implement new features, rewrite mechanics, or make a whole new gamemode.
• ✨ Customize Assets - Replace models, swap colors, or give the whole level a new aesthetic.

Seeing my team use the engine & tools I created has been a great learning opportunity for me. It teached me a lot about user experience, usability, and how to make an engine that is intuitive and easy to use. Open sourcing the game + engine will allow me to continue to learn and improve the engine based on feedback from players.

Read more about the engine release in this blogpost I wrote on itch.io.

🏆 Awards!

At the end of the year, we had an industry day. This day people from the industry came to see all projects/games build by students this year. We had a booth where we showed the game running on PS5 and engine showcase.

At the end of the day, we had an award ceremony. Our team won 3 out of 4 Awards from our year!

• 💾 Best Tech - Most technically impressive project.
• 🎮 Best Design - For the design of the puzzles and the game mechanics.
• 🏆 Industry Award - Best project voted by people from the industry.

Downloads

The game + the engine is available to download on itch.io. I released a tech-demo that showcases the engine and some of its features. It has Chess and some cool destruction!

Interview

At the end of the block Max Coppen (teammate) and I were asked to do an interview for the Buas website. This article can be read here.