The Unholy Society is a game inspired by 80s and 90s action movies as well as comic book series such as Preacher and Constantine. It presents a world captured by the united forces of demons and monsters.
All Reviews:
No user reviews
Release Date:
Q3 2018
Developer:
Publisher:

Sign in to add this item to your wishlist, follow it, or mark it as not interested

Available: Q3 2018

 

Recent updates View all (6)

March 28

Behind the Society: Drawing from Comics



We love comics, and we wanted all the conversations in the game to look like drawn straight from the visual novels. Comic books have by now developed a substantial “standard language” how to convey some ideas.

Bubbles of all shapes and sizes

For example, there are clearly defined ways how to differentiate between someone speaking and whispering, or just speaking with a weak voice and the narrator bubbles often have a distinct background.

We also knew that we will have some… “special guests” speaking. This is the game where you can speak with The Devil himself, and his comic bubble should not look like a mere mortal. For this, we looked at how Neil Gaiman’s The Sandman uses various comic bubble types to represent various special characters (like “the endless”). E.g. the Dream has a special bubble that is filled with black, has a strong white outline and is wobbly. You automatically imagine that it’s not a normal voice speaking these words.

So, we wanted it all in our game :) To achieve this, we developed a simple system of defining comic bubble types. We have many comic bubble types, and each type may have different shape, outline, colors and font. Each NPC can have his/her special bubble type, also a particular phrase (like shout) may use a particular comic bubble type.

Here’s how hero shouting may look like:



The simplest, early comic bubble type looked like this when designed in Blender:



As you can see, a bubble type has actually three bubble shapes: one to the left, one to the right, and one going to the top. We use a particular direction in game depending on various things. In the “walking view” the direction (usually) depends on the direction between a speaker and a listener. In the “first-person view” (when we fight) the direction depends on the position of speaker’s mouth on the screen.

Oh yeah, each NPC has a specifically configured “mouth” position.

Inside the bubble, we have a special area where the text must fit. We first put the text inside, wrap it, and then we adjust bubble scaling to make the best fit around the text.

The screenshot above shows a comic bubble for “choice”, used when a player needs to make a choice in the conversation. The three bubbles never overlap each other, this way choices are displayed correctly. This is how it looks like in game:



When a person speaks, we use a different bubble shape:



Will it blend?

We use Blender’s Bezier curves to define comic bubble shape. And we make some comic bubbles animated, using Blender’s “shape key” animation, exported to Castle Game Engine animation format.

During the game, we wanted to show “hints” to the player, indicating that a player can press something to interact with something (enter a house, speak to someone). We realized that this can be nicely shown as a comic bubble indicating that a hero is thinking: “Hmm, I can enter this house…”. Comics have already established a standard how to show a “thinking bubble” of a person, so we can use this.

Here’s how the “thinking” bubble looks like in Blender:



And here’s how it looks in game:



We have plans to extend the system, and use it more intensively. E.g. we have not yet used the feature "various NPCs and various phrases may have various bubble types" as intensively as we want to. We will!

If you like our “bubble science”, please add The Unholy Society to your wishlist to stay up to day with all further announcements.

0 comments Read more

March 1

Behind the Society: The Science of Conversation


One half of our game, ]The Unholy Society, is an adventure game. You walk around, talk with people, make choices and explore the storyline. We have developed a system, a simple scripting language, to better define adventure games like ours.

Even though our “game designer” is also a programmer, he wanted to separate the game logic from the game’s core source code. This way, the logic, as in, “you cannot enter the church before you speak with aunt” is specified in a different place and a different language, than for example, the logic of how to load Spine models and animate them in the game.

So, we’ve made a script system, designed with "conversations", as a primary use-case. We call it “The Unholy Conversations”.

As the name suggests, the first use-case is for when a player talks with one or more NPCs. However, the system is also useful to define cut-scenes: NPCs can talk (with or without the player) and animations in the environment and the NPCs can be run and so on. The scripts are also run when you enter a location or a particular area of a location. When the player is inside a “sensor” (a simple rectangular box), a script decides whether the player can interact with something and what happens when (s)he does.

How it looks

It’s a set of files, named something like “<name>.conv.txt”. The <name> decides when the script is run. For example, the file “aunt.conv.txt” says what happens when you start a conversation with the “aunt”, one of the NPCs in the first act of our game. The file may look as simple as this:

aunt: Hello dear.
hero: Hello my dear auntie!
aunt: You're late.


Simple enough, right? If a line starts with “xxx:” then it’s just someone speaking. “xxx” can be the name of an NPC (it can also be empty to indicate this NPC, which is implicitly “aunt” within “aunt.conv.txt” file) or just “hero”.



A central part of the conversation is choices. They look like this:

aunt: Go to Edward.
-> Why are you so suspicious when it comes to the Vladinsky family?
aunt: I'm not sure are they a good influence on our Susan.
-> Can I talk with Susan?
aunt: She's getting dressed. There's no time for chit-chat now.
-> Bye then.
aunt: See you soon.
->


As you can see, each choice is just a line that starts with “->”. They all must have the same indentation (hi, Python lovers!) and they must end with an empty choice. This way you can have nested choices too. Note that the choices are (right now) always spoken by a hero and this is why, in the text above, we do not clarify who says, “Bye then”.



To enable simple loops within a conversation, one line may start with a label like “label start” and another line can then jump to it, like “go-label start”. This allows the creation of conversations where you can inquire with an NPC about something, like an investigation, and only exit the loop once you are satisfied (or you have exhausted all the options). The label mechanism does seem like the unpopular “goto” mechanism, abolished from most high-level programming languages, yet here it works perfectly. It’s simple (the conversation files are always short and jumps are only within a single conversation, of course) and flexible, as it allows jumps to different locations.

Variables and tests

A game logic remembers the state of the storyline.

Take for example, “Have you already spoken with aunt?”. This particular information (if you have already visited someone) is actually very often useful. All the conversations (and thus, all the NPCs and all locations) have an automatically remembered state of “visited”. It’s a simple boolean flag (it can be true or false). It is initially false and then automatically changes to true once you have spoken with someone.

You use a variable in simple boolean expressions together with the “if” instruction:

if not visited
aunt: Finally! There you are!
hero: Hello my dear auntie!
aunt: You're late.
endif
aunt: Go to Edward.


Here we use the automatic variable “visited”. Like in every good programming language, variables are placed in namespaces, with each conversation being a natural namespace. This means that another NPC can say different things depending on whether you have spoken with aunt:

if not aunt.visited
uncle: Your aunt is waiting for you in front of the church!
else
uncle: Go on, boy.
endif


Another automatic variable is “gate”. Some NPCs simply won’t let you through until you have done something. For instance, you cannot talk with Susan too early in the game, as you have seen in the above snippets. Once an NPC decides that you can pass, it can “change” the gate status doing “set gate false”.

Finally, every conversation can have it’s own custom variables. This can be used to store any game state. For example, the aunt could have a variable like “is_angry”. You can declare such a variable within a conversation file and use it (read or write) from this or other conversations. For instance, a conversation with aunt could end badly for you:

declare is_angry false
aunt: Go to Edward.
-> Right away!
aunt: Attaboy!
-> Come on, do I really have to?
aunt: Yes, you insolent brat.
aunt: I remember when you were young and…
hero: OK, OK, I’m going…
set is_angry true
->


Now, another NPC or the aunt could use this flag: “if aunt.is_angry”.

As you can see, all the variables must be declared and the declaration must specify their initial value. In this example, the aunt is initially not angry (but watch out, you insolent brat!) That said, it’s a secure and reliable programming language. Only special “automatic” variables, like “visited” or “gate”, do not need to be declared.

Naturally, all the conversation variables are saved to the save-game. This allowed the save-game code to be quite simple: just write all the variables to the save-game.


Other cool stuff

The conversations can cause a variety of actions. They can teleport the player or an NPC. They can make some NPC or asset appear or disappear. They can play a particular animation. All of this is smartly saved to the save-game, so the game designer does not have to worry about these technical details when designing the game logic.

All the scripts are automatically validated (they use existing variables, are connected to the actual data, etc.). This makes modifying these files safe and testing is easier when the computer automatically detects some of your mistakes. Right now the testing is done each time the game loads (it takes a fraction of a second now - less than 1/10 of a second), but it may be moved to our continuous delivery process (using Jenkins) later.

Inspiration

We have designed a conversation system once before, for our not-yet-released game, The Venice. It had some good ideas and we have borrowed some of them. But it was also not comfortable enough to write a large amount of logic… what we have now, The Unholy Conversations, is both simpler and more flexible to use.

We have looked at other conversation systems as well. One in particular was from an excellent indie game, Night In The Woods, which is public and documented on https://github.com/thesecretlab/YarnSpinner/ . We have borrowed various ideas from it, e.g. that the “talk” lines should be simple to write, the “visited” state should be tracked automatically and the “if” and choices should be easy.

The “Yarn” language was, in turn, inspired by Twine, a simple text format for telling non-linear stories with choices.

Twine is also renowned for its simple-to-use graphic editor for stories, although we quickly decided that a graphic editor was not as useful as it sounds for things like our game conversations. Conversations in games need to depend on various variables and they need to be written easily. Wrapping them in a graphic editor felt unnecessarily limiting. We’re programmers, we work fast with a text editor and a clean programming language with simple syntax -- so that was our focus on The Unholy Conversations.


The Future

After the development of The Unholy Society and once we catch our breath, we plan to make this system independent from the game and release it as an open-source component. We’re huge fans of open-source here (we use our own open-source Castle Game Engine for the entire game development), so in doing so, we will give back to the community too.

If you appreciate our dedication and want to know more about the game, please add The Unholy Society to your wishlist to stay up to date with all further announcements.
0 comments Read more

About This Game



The Unholy Society is a game inspired by 80s and 90s action movies as well as comic book series such as Preacher and Constantine. It presents a world captured by the united forces of demons and monsters. The Werewolf King, the Great Old One, Satan, the Great Voodoo Shaman and Dracula join forces to eradicate love and bring eternal darkness to the world, and perhaps to also drink lots of tea and discuss art. The only one with a chance of stopping them is our amnesiac exorcist. At the request of the Pope himself he sets off on the quest to fight for good and justice, leaving behind a trail of cigarette butts and empty whiskey bottles.



A retired exorcist is forced to don his cassock one last time to save the world. Lying on a bed in a dingy hotel, the exorcist was unaware that his one night stand beauty would become a threat… Just after midnight she revealed her demonic face and perfectly sharp, though very unwomanly, claws. As it turned out later, this case wasn’t the last. A sect of the most powerful and the most iconic bad guys of pop culture threatens the world. Only our hero can stop them with the help of his lackluster faith. Will his dusty Bible, revolver and a wooden stake be enough? Will the exorcist recover his lost memories and regain his abilities?



* Storyline inspired by popular themes from movies and comic books like "The Exorcist" and "Constantine", with a humorous twist
* Comic-style graphics
* Unique fight system, both turn-based and live-action, by performing an exorcism
* The only adventure where you can call the Pope and ask for help

System Requirements

Windows
Mac OS X
SteamOS + Linux
    Minimum:
    • OS: Windows 7 or newer
    • Processor: 1,5 GHz
    • Memory: 2 GB RAM
    • Graphics: any GPU card with 3D acceleration and latest drivers
    • Sound Card: any sound card compatible with OpenAL (includes all sound cards compatible with DirectX)
    Recommended:
    • OS: Windows 7 or newer
    • Processor: 1,5 GHz
    • Memory: 2 GB RAM
    • Graphics: NVidia or AMD GPU with 1 GB VRAM
    • Sound Card: any sound card compatible with OpenAL (includes all sound cards compatible with DirectX)
    Minimum:
    • OS: MacOS 10.10
    • Processor: 1,5 GHz
    • Memory: 2 GB RAM
    • Graphics: any GPU card with 3D acceleration and latest drivers
    • Sound Card: any sound card compatible with OpenAL (includes all sound cards compatible with DirectX)
    Recommended:
    • OS: MacOS 10.12
    • Processor: 1,5 GHz
    • Memory: 2 GB RAM
    • Graphics: NVidia or AMD GPU with 1 GB VRAM
    • Sound Card: any sound card compatible with OpenAL (includes all sound cards compatible with DirectX)
    Minimum:
    • OS: Ubuntu 16.04 LTS
    • Processor: 1,5 GHz
    • Memory: 2 GB RAM
    • Graphics: any GPU card with 3D acceleration and latest drivers
    • Sound Card: any sound card compatible with OpenAL (includes all sound cards compatible with DirectX)
    Recommended:
    • OS: Ubuntu 16.04 LTS
    • Processor: 1,5 GHz
    • Memory: 2 GB RAM
    • Graphics: NVidia or AMD GPU with 1 GB VRAM
    • Sound Card: any sound card compatible with OpenAL (includes all sound cards compatible with DirectX)

What Curators Say

1 Curator has reviewed this product. Click here to see them.
There are no reviews for this product

You can write your own review for this product to share your experience with the community. Use the area above the purchase buttons on this page to write your review.