Re:creation dev log. March-June 2016. Part one. Game stuff and and some awesome Lua scripting

The last few months I was very busy finishing my bachelor’s degree (it’s over, I got an “A”!). But still, I’ve managed to do some cool stuff and improve the engine structure and tools in the last couple of months.

This dev log will be released in two parts. In this part I’m going to talk about game stuff I did and stuff I changed about Lua/C++ integration. In the second part I’ll talk about engine tools I’ve made with ImGui and different refactoring I’ve done.

Game stuff

Here’s one of the latest screenshots of the game. Houses were previously just big sprites, but right now they’re composed out of tiles which lets me reuse them for other houses and build new buildings more quickly.

Creating awesome GUI for you game dev tools with ImGui and SFML. Part 1.

This is the first part of tutorial about Dear ImGui (AKA ImGui) and it’ll show you how to set it up with SFML. The second part will be library agnostic and will talk about common ways of doing stuff in ImGui, some awesome widgets and some useful STL overloads.

Different ImGui widgets (taken from ImGui’s github page)

Introduction

Having good content creation (level editor, resource editor, etc.) and debugging tools for your game is very important and can lead to productivity and creativity boost.

Here are some examples of tools I managed to make with ImGui for my game:

Level editor:

Animation editor:

(It was possible to add ability to change members of C++ objects with ImGui by doing some template magic, maybe I’ll write an article about that later!)

As you can see there’s a wide range of widgets that ImGui can provide and there are lots of other great examples of how other people use it here.

Re:creation dev log. January-February 2016. Better art, sounds, cutscenes and more!

Just a short info for those who have never heard about my game.
Hello, my name is Elias Daler and I’m a solo developer who is making Re:creation in my free time. It’s done in C++ with SFML and Lua!

Re:creation is an action adventure game about the undead knight who wants to free undeads from the humans who use undeads as slaves or practice dummies. The unique mechanic of the game is called recreation which allows you to control dead people with your ghost gaining their abilities to solve various puzzles. Here’s an example of this puzzle.

Read more about the game here.

 

Back to the dev log…

Two months have passed since the last dev log. I had lots of time to work on the game and here’s what I’ve  managed to work on.

Better art

Yet again, another graphics improvements! Change of the perspective was quite an improvement, but I’ve also realized that I can improve other stuff too.

There’s more depth to characters and surroundings, the colors are used better, etc.
There are more graphics improvements which I’ve done recently (for example, I’ve improved main hero’s sprite a lot), but I’ll show it off a bit later.

Here are some comparison screenshots!

There are also subtle things that made game look better!

Re:creation dev log. 2015. The most productive year yet.

It’s time to summarize what I’ve done during this year with Re:creation. It has been very good year, I’ve managed to do and learn lots of stuff.

Before I write about the stuff I’ve done I want to thank everyone who followed my progress and provided feedback. This stuff is really important for me and always keeps me motivated. With your support I never feel doubt about my game, I never want to stop making it. Thank you.

Special thanks to SFML community. It turned my dev log thread into a very cool discussion and helped me out with lots of stuff. This level of support is much more than I’ve ever expected and it’s very heartwarming.

I’ll show the most interesting stuff I’ve done and then explain some in more detail.
Some screenshots are taken at different parts of the year, so they may differ a lot!

Some gameplay gifs to get you started:

This one is my favorite gif so far. It really shows a lot of stuff I’ve made this year.

Using Lua with C++ in Practice. Part3. Controlling entities in Lua by calling C++ functions.

• Part 1. Intro to ECS and basic principles
• Part 2. Implementing the basics
• Part 3. Controlling entities in Lua by  calling C++ functions.

If you haven’t read the first part of the tutorial, I suggest you to read it, so you have a clear idea what’s going on. See the second part for the implementation details.

This article uses LuaBridge and if you’re not familiar with it, I suggest you to check out my tutorials about it. (Pt1, Pt2). If you’re using another Lua/C++ binding: that’s fine, you can totally implement everything I’m talking about with other bindings.

Intro

One of the coolest things in Lua is that you can call C++ functions from it. You can even register your own classes and call their member functions!

Suppose you have an entity class which contains a list of components:

class Entity {
    ...
private:
    std::vector<std::unique_ptr<Component>> components;
};

Suppose that you have a function which lets you get a component by its name.
What if you want to change animations in some Lua script? You can do it like this:

function someLuaFunction(entity)
  ...
    local graphics = entity:getComponent("Graphics")
    if(graphics) then
        graphics:setAnimation("someAnimation")
    end
  ...
end

I believe that this is not a greatest way to do things, because exposing components to Lua is not really necessary. Woudn’t it be nice to hide all the implementation details in C++? Here’s how the code above may look:

function someLuaFunction(entity)
  ...
    entity:setAnimation("someAnimation")
  ...
end

Re:creation dev log. June – October 2015. I’ve made lots of stuff.

Almost five months passed since the last dev log on this blog.
Why? That’s because I created SFML forums thread and TIGSource thread and wrote most of the stuff about the game here! But I’ve realized that a monthly summary about what’s going on would be pretty helpful for those who don’t want to read long threads and search the most awesome stuff that’s been happening. Another plus is that I don’t have to write lots of in-depth style here. I will write in-depth stuff in SFML forums and TIGSource threads and link to those posts here, so you don’t have to scroll through stuff that you don’t want to read lots about.

Here’s the best screenshot I can show you at the moment to show where the things are right now.

Okay, let’s start.

Using Lua with C++ in practice. Part 2. Implementing the basics

Source code for this article

• Part 1. Intro to ECS and basic principles
• Part 2. Implementing the basics
• Part 3. Controlling entities in Lua by  calling C++ functions.

Hello, this is a second part of “Using Lua with C++ in Practice” series. I recommend to read the first part to know what’s going on and why using Lua with C++ is awesome! (You’ll see it in this arcticle too, of course).

This tutorial will implement a simple ECS model which I’ll improve and use in other parts of tutorials. Note that this is not the best way to implement ECS. I’m making the most basic ECS which can be used to show the main principles of how things work in my game and how you can use them in general. This is not a tutorial about C++, so I won’t spend too much time discussing C++ parts and I’ll mostly focus on Lua/C++ interaction and binding. Let’s start!

Using Lua with C++ in practice. Part 1. Intro to ECS and basic principles

• Part 1. Intro to ECS and basic principles
• Part 2. Implementing the basics
• Part 3. Controlling entities in Lua by  calling C++ functions.

There are many reasons to use Lua with C++. One of them is that you can put some of the logic from C++ code into scripts, so you can easily change them without the need or recompilation. You can also write some good interfaces, so the scripts are easy enough for even non-coders to write them. Lua is free, Lua is fast, Lua is used in game development quite often.

While there are plenty of good articles about using Lua with C++, I think there are not enough articles about how to use Lua in real projects.

This article is one of the many articles I plan to write. Here are some topics which my articles will cover:

•  Entity creation and other basic stuff (you’re reading this now)
•  How to implement entity creation
•  Managing Lua state and cleaning up
•  Scriptable state machines
•  Events and callbacks

The stuff described in the articles was mostly discovered during the development of my game called Re:creation.
I don’t think the methods here are perfect, but they’re good enough, fast and work well for me. So, your feedback is welcome. Feel free to leave comments and write e-mails to me about the stuff I can do better. I’m interested in hearing about your Lua/C++ usage!

While this is a C++ article, I think you can implement most of the things mentioned here in your favourite language. I’ll use Lua C API and LuaBridge for examples, so I recommend to read the following articles if you’re not familiar with them:

• Using Lua with C++ (Part 1)
• Using Lua with C++. LuaBridge

Re:creation dev log. March 2015. Graphics improvements, entity inheritance, improved state machines and more!

This month was great. I finally got in the flow of development and managed to get lots of things done. I worked hard to make game look better and here’s the result. Compare old screens with new screens:

October 2014

 

March 2015

Re:creation dev log. December 2014 – February 2015. Bigger levels, boss and heavy attack

A long time has passed since I’ve written the last dev log! Is Re:creation dead? Is it stagnating? No, not at all. It’s more alive than ever now!
I haven’t written a new part of dev log because I had to study a lot in December and January. I had some time to develop some stuff during these month and had a lot of stuff done in February.
I’ve decided to write the dev log in two forms

• First one will be about the features I’ve implemented recently and it will have a lot of pretty screenshots and gifs. (You’re reading this part right now).
• Second one will be more specific and I’ll focus more on technical parts of the game and implementation details of some interesting features. This part is a lot harder to write so it’ll be less frequent than the first one.
  If you’re wondering about how I’ve implemented one or another feature of the game or its engine, feel free to write an email and ask about it! I’m always glad to answer.

Well, let’s start.