ratrogue’s log
www.fholio.de
SEEN / PLAN / DONE / contract work not included
posting on https://mstdn.io/@ratking too
2024-04-21
SEEN
- TIL that for Godot’s Color Correction adjustment LUTs you have to set only the Horizontal setting of the 3D texture to 33, not Vertical too. Now all our screenshots and trailers are obsolete as we actually always used the LUTs in the wrong way… oops.
DONE
- Last week I gave a Godot course and also supported students in a game jam; one team even used Godot. Pretty intense. Nothing to add here.
- When editing a level scene for Mops & Mobs I'd like to directly test it sometimes via F6 - but in our game the level can't be run standalone, it needs a game scene first. This is what I came up with after several tries: removing all child nodes' scripts so nothing unwanted happens that depends on the game scene in _enter_tree(), and a while later in _ready() finally load the real scene while also telling it which level scene to load via a static variable.
https://mstdn.io/@ratking/112305900817022858
2024-04-15
SEEN
DONE
- I mostly abandoned the project I continued from the Dungeon Crawler Jam that I couldn’t submit, and instead got back to my “ratrogue philosophy” kitchensink project. All I did though was porting the ladders from 666 Coins. Small steps, I suppose (literally).
2024-04-10
SEEN
- This four hour long retrospective about the Diablo series was an interesting watch as it touched a lot of game design relevant themes. The gameplay is mesmerising for sure, but even by just watching the guy’s killing of thousands of demons I felt like wasting time.
https://www.youtube.com/watch?v=R3v-7Rndd8M
2024-04-07
SEEN
2024-04-05
SEEN
- I noticed some superfluous code in a maths function by Unity. I’m not super confident the C# compiler can optimise this out, but it should be easy to check that too. Anyway, an interesting look into the internals.
https://mstdn.io/@ratking/112218125483781231
2024-04-01
SEEN
2024-03-30
DONE
- I’m participating in the Dungeon Crawler Jam 2024, even though I dislike the restrictive rules. Of course I want to finally do the stealth gridder idea I had, but even with the limitations I’m imposing on myself I can’t finish, mostly because of motivation and family reasons. Still, I did a small level in bloed, with a heavily TRON inspired style, and the enemies are mostly working too. I can see myself actually trying to finish at least a working MVP for this.
https://mstdn.io/@ratking/112183697750209982
2024-03-22
PLAN
- I think I’m going to rename connected, the name isn’t searchable at all.
2024-03-14
DONE
2024-03-10
SEEN
2024-03-06
DONE
2024-03-05
SEEN
2024-02-28
SEEN
- Nice, in Godot you can find out via Node.scene_file_path if a node is actually instantiated from a scene - if it’s not empty, it’s instantiated. This is something I miss sometimes with Unity’s prefabs.
DONE
2024-02-25
DONE
2024-02-23
DONE
- I updated Connected to v0.9.4. If the bugs that I fixed really are fixed now, then it’s pretty much “ideal” now, missing only things like editor localisation and other nice-to-haves. It’s good we use it for Mops & Mobs, otherwise it would have been a total waste of time. (Because nobody else is using it.) In any case I want to upload my Godot glue code in a few days.
https://ratking.itch.io/connected/devlog/686829/connected-v094
2024-02-22
SEEN
- A video about some kind of texture projection painting in Blender. I remember SophieH’s tool pixexix doing the same, it’s nice that it’s possible to just have this in Blender now.
https://www.youtube.com/watch?v=oW7zKbylReI
- After evaluating the Godot first-person controller some more I have to conclude that it’s nice for some simple stuff, but the fact that it can’t even step over simple stairs is a big downer. Apparently this is an ongoing issue in Godot.
https://github.com/godotengine/godot-proposals/issues/2751
2024-02-19
SEEN
2024-02-13
SEEN
- I watched and followed the first part of a tutorial series for a first-person controller in Godot. The code is somewhat bad, but at least it gives me an idea of how to approach this in Godot, even though it all feels very incomplete. For example using a raycast to check if you can stand up after crouching probably doesn’t work well with slopes.
https://www.youtube.com/watch?v=xIKErMgJ1Yk
2024-02-09
DONE
- Another update for Mops & Mobs - mostly adding a dialog history. With the dynamic nature of the dialogs this isn’t as straightforward as I wish it would be, and could lead to an enormous amount of (redundant) backlog, even if we only save the localisation IDs and not the actual texts. On the other hand, memory is cheap and if people want it, I won’t deny it to them.
https://ratking.itch.io/mops-and-mobs/devlog/679819/v009
2024-02-07
DONE
2024-02-05
DONE
- We made the itch.io page for Mops & Mobs public, to find people giving feedback. We think it’s a nice idea for a game, but maybe the majority hates it - better finding it out now than later.
https://mstdn.io/@ratking/111880031215066901
2024-02-04
DONE
2024-02-03
DONE
2024-02-01
SEEN
DONE
- We’re pretty much finished with the first playable prototype version of Dungeon Novel - in the sense that there is a beginning and an ending and also some things to do in the middle. It also got a final name, Mops & Mobs - A Sweeping Dungeon Novel. The “sweeping” part is not yet much part of the game, so that would be one of the next goals. Unfortunately we first have to wait for funding; if we won’t get it, then we will have to work on the game on the side and do contract work or other things instead. In any case it would be nice to continue with Mops & Mobs, like adding combat and of course the rest of the game’s story. Also the quests are very boring and typical right now, more exciting quest lines would be great.
https://mstdn.io/@ratking/111852031209405333
2024-01-22
DONE
- As there wasn’t a post-effect on the Godot shaders website that does what we want for the dungeon visual novel game, I now ported smoke_fumus’ DarkBringer shader, at least the parts that are relevant to me.
https://mstdn.io/@ratking/111798431678956885
2024-01-20
SEEN
2024-01-19
SEEN
DONE
- For our still not named dungeon visual novel project I “rewrote” a shader that would do some dithering via a SubViewport so that it could be used on a quad-based fullscreen effect. Pretty trivial. The thing is that it made me want to change the shader so it wouldn’t just be luminance-based, but use a full palette; I have no idea how to go about this yet. I might have a look at smoke_fumus’ shader that I bought for Unity once, it’s still pretty much the best I know.
- For the dungeon project I also implemented a first version of the decorator mode. It’s very basic and not yet working correctly in all cases. For example, torches are placed upside-down sometimes. Here I should have a look at my old torch placement code that I wrote for Behind Stars and Under Hills.
- As a small side note, I replaced the .json files I used for creating various configuration definitions (for dialogs, NPCs, quests) with Godot resource files. While the overview is a bit worse - instead of having everything in one file information is now distributed over several .tres files - I guess it removes uncertainties and is less error-prone. In the end it’s just like using ScriptableObjects in Unity.
2024-01-10
SEEN
DONE
- I finally understood the Multiplayer nodes in Godot - MultiplayerSpawner and MultiplayerSynchronizer. I had some problems because I think the documentation isn’t the best in regard to these. One of the issues happened when I tried to give an instantiated node the authority of the client; the simplest sample code uses the node’s name for that, which was handled by MultiplayerSpawner, but I find that’s a hack and can break. So I tried to set the authority ID by using a property in MultiplayerSynchronizer, and that didn’t quite work, as the MultiplayerSynchronizer only works when the object already has the authority. Anyway, I’m applying the authority via an RPC now, and while I’m not too happy with that, at least it works. In any case I will always feel like a noob when it comes to networking, even though I did some multiplayer prototypes. This was over a decade ago, so there’s that.
2024-01-07
SEEN
- Today I learned that Unity’s SphereCast isn’t that simple to reproduce in Godot, one has to use both PhysicsDirectSpaceState3D.cast_motion() and .get_rest_info() to get similar information. I find that this should be more documented. I also had problems first understanding what cast_motion() actually returns - it’s interesting from a physics engine perspective, but quite confusing if you just want to use the function. Both values of the returned array contain the percentage of the motion when it collides, but the first is without the collision actually happening and the second with the collision, so only a tiny bit higher.
https://github.com/godotengine/godot/issues/2217#issuecomment-117429233
2024-01-05
SEEN
2024-01-03
DONE
- Adding ?System.Date.Now.Ticks to the url for the JSON file (that has the version info and the available .BAS files) helped with my problem of Firefox not downloading the latest version but some (internally?) cached one. Thanks to voxel for the suggestion. I don’t think Games for Rats will get another update, but it was nice to get back to it - it also made me dream of a Terrobot X game again; I still find the idea extremely intriguing.
2024-01-02
DONE
2023-12-22
DONE
2023-12-18
SEEN
2023-12-08
DONE
2023-12-06
SEEN
DONE
2023-12-05
DONE
- My dialog editor connected is now version 0.9.0 - I mostly wanted to reintroduce configuration files, this time optional. A config file can be added via the command line, and overwrite all the used paths. This became necessary as we’re now working on a small side project, and it would be a hassle to change all the paths every time I use connected for something else. (Would be nice.) Also the SCRIPT node is now much more powerful, because I’d like to have “nested” dialogs again, i.e. dialog nodes that load other dialog files, and then continue when that’s done - and I didn’t want to introduce a new node type for that, at least not by default.
https://ratking.itch.io/connected/devlog/645881/connected-v090
2023-12-01
DONE
2023-11-29
SEEN
2023-11-27
SEEN
- Via OS.has_feature(“flag”) you can check different things, like editor, debug and release - wish it had a preprocessor instead though, but GDScripts are not directly compiled, so the code wouldn’t get removed anyway
- Via _get_configuration_warning() -> String / update_configuration_warning() you can tell @tools scripts to show a warning, for example if something’s missing
- Via _get_property_list() -> Array it’s possible to export variables in a cooler way, providing your own property list and notify when this list changed; I didn’t quite get it, but it seems like it would allow for dynamic inspectors like with Odin for Unity
- Any scene this is derived from the Control node (and is removed in _exit_tree()!) can be added to
- main screen: get_editor_interface().get_editor_main_screen()
.add_child(<inst>) - bottom panel: add_control_to_bottom_panel(<inst>, <title>)
- dock: add_control_to_dock(<dock>, <inst>)
- container: add_control_to_container(<container>, <inst>)
- Inspector plugins can create custom widgets in the inspector
- To automate Godot related things without starting up Godot, you can use the command line interface (CLI):
- –export-release/–export-debug <preset> <path>
- –debug-server <uri> - start a debug server
- –script <script> - run a script standalone
2023-11-26
SEEN
2023-11-25
SEEN
- I’m watching Godot videos from time to time, as I want to dive in deeper and get really comfortable with this engine. This talk about viewports was very interesting indeed.
https://www.youtube.com/watch?v=cwZGq1qJYoQ
DONE
- After finding out about a simple method to pack the 32 bit depth value of a viewport in Godot into the 24 bit albedo output, I finally could do the selective outline/highlighting shader that I was aiming for. It does need Godot 4.2 though.
https://mstdn.io/@ratking/111472503848823339
2023-11-19
DONE
- I gave up trying to get a depth map from a viewport in Godot 4 - I posted my findings on Mastodon. Biggest problem is that rendering the depth_texture to a normal texture is resulting in a major loss in precision; even with the upcoming Godot 4.2, where you can activate HDR for viewports, there are at least 8 bit missing. (A solution could be to somehow encode the 32 bit depth value into 2 16/24 bit floats, but I haven't found a reliable way yet.)
https://mstdn.io/@ratking/111438802280426776
2023-11-18
SEEN
- As I’m diving deeper into GDScript nowadays, I learned that there are no destructors, but you can simulate item like this:
class Test:
func _notification(what:int):
if what == NOTIFICATION_PREDELETE: print("goodbye")
An important side note is that Test is automatically inheriting from RefCounted, not from Object. An Object wouldn’t get deleted automatically at the end of the scope. - Moreover, set_as_top_level(true) will make a Node3D object independent from its parent’s transform - very useful and something I’d like in Unity.
2023-11-16
DONE
- For our current prototype game in Godot I ported my connected glue code to GDScript. It was mostly hassle-free, and I also noticed a bug in the C# code, so this activity was doubly useful.
2023-11-14
SEEN
- A talk about C# and Swift and Godot, basically. It’s by the guy who founded the Mono project, so his knowledge is actually relevant, and he says he wouldn’t use C# for game development. I can understand why. Not sure I’d like Swift though.
https://www.youtube.com/watch?v=tzt36EGKEZo - For Unity I created a simple extension method for Vector3s so I can simply put a vector on the XZ plane by writing flooredVector = myVector.WithY(0f) - with C# 10 I could now write this as flooredVector = myVector with { y = 0f }!
- In Godot, instead of using str() I can format strings like this: “The %s is %s” % [ “number”, 12 ] - not much of a fan of the syntax though.
DONE
2023-11-12
SEEN
- Godot: You can import Blender files directly
- Kenney’s textures are in Godot’s add-ons, ready to download with a click
- You can tell a material to use triplanar mapping, even per object or not
- get_tree().quit() quits the scene
- To lock the cursor, set the Input.mouse_mode
- The RESET track is quite important for animations
https://www.youtube.com/watch?v=ghYilg9cq-I - Use the MultiplayerSpawner node to automatically spawn something on both instances. The MultiplayerSynchronizer node is also self explanatory
- Calling a method on all instances, use the @rpc(call_local) annotation and call it via my_method.rpc()
- Use the UPNP stuff for playing over internet
2023-11-11
DONE
- I participated in the Auswärtig gespielt game jam. It actually was a “mod jam”, but as I already personally predicted nobody really would do a mod for a game - it just adds limitations and complications that are not helpful in a jam, especially if it only goes for approximately one day. I was part of a team of five people, and we made a prototype for a game about cultural migration and merging. We called it Culture Carom. I didn’t want to be the programmer this time, but in the end I did most of the UI and gameplay code. It can’t be helped I guess. The whole jam experience was quite intense, and unfortunately we didn’t win anything (there were 4 winners out of 12), but I wasn’t there for the money anyway. (Although in some sense I was there for the money - the whole event thankfully was free: travel, food and hotel were all paid for by the taxpayers. Thank you!)
https://www.stiftung-digitale-spielekultur.de/modjam-aussenpolitik-auswaertig-gespielt/
2023-11-09
SEEN
2023-11-07
SEEN
2023-11-05
SEEN
- F9 brings back the last action manipulation window.
- Repeat the last action with Shift+R.
- When having vertices/edges/faces selected, Shift+G lets me select similar ones.
- When pressing double G to move open edges, one can keep pressing Alt or C once to be able to move the edges even farther.
- When selecting two different faces with Shift and Ctrl pressed, it actually selected a rectangle of faces.
- Shift+B lets me zoom into a self drawn view of the scene.
- With Alt+B, I can clip the model for easier manipulation!
- Alt+Z activates the x-ray mode, so I can select vertices on the back sides. Alternatively, keep Z pressed and move down in the ring menu.
- With the Tool Settings (under View menu) I can get a toolbar that lets me auto merge vertices!
- Ctrl+X is for quick dissolving of verts and edges.
- X → Limited Dissolve removes unnecessary edges and vertices only.
- I forgot you can extrude something to your mouse position by just pressing Ctrl+LMB.
- Alt+S is for shrinking/fattening in a quick way.
- Use Ctrl+F to quickly solidify some faces. Shift+N recalculates the normals.
- Ctrl+F is also good for quick boolean cutting of two mesh parts.
- Press C while cutting (K) a mesh, then the cut goes through all faces, on the back too.
- Under the Object Data tab, activate “Auto Smooth” for the Normals, to get a much better smoothing result.
- Insetting (via I) has a lot of options, just look at the shortcuts bar.
- “Active Element” for the Transform Pivot Point helps with objects not aligned to world axes.
- Shift+R iterates the last action done. Good when having used Shift+D for duplicating and moving an object.
- There’s a Boolean quick menu in the add-ons that is deactivated by default. The same with the LoopTools, also a useful add-on.
- Alt+G, Alt+R, Alt+S resets position, rotation and scale.
- I can move the pivot via the “Affect Only Origin” mode in the small Options on the top right.
- There’s a menu to change the transform randomly!
- By right clicking on location/rotation/etc. you can copy a transform to another.
- The Quick Favourites menu (Q) is very useful and you can add stuff yourself by right-clicking anything.
- Keep pressing Alt while manipulating numbers etc., and all selected objects will get applied the value, instead of only the active (last selected) one!
- Ctrl+L is powerful for linking stuff from one object to several others, for example modifiers or materials.
- To add hooks to vertices, press Ctrl+H.
- To control the thickness of the Skin modifier in individual vertices, press Ctrl+A.
- Select objects in the hierarchy (Outliner) and press Ctrl+F2 to batch rename them.
- Press M for putting objects into collections quite quickly.
- With Shift+A you can create an instance of a collection!
- If you want to reparent objects inside the Outliner, press Shift while dragging them around.
DONE
- I’ve done another small prototype in Godot, this time about a roguelite-esque combat system. It’s bad, but at least I could define my base code for Godot a bit, adding some kind of component system. No idea if it’s good, but I feel I can write GDScript much more comfortably that way.
2023-11-04
SEEN
- I've been a fan of Warren Spector for a long time, and reading his article about his 40 year long career (so far!) brought back some fond memories of most of his games. I neve played Epic Mickey (too console-y), but his dedication to Immersive Sims is still an inspiration to me. The article left out Underworld Ascendant, which is telling in itself, somewhat.
https://www.gamedeveloper.com/blogs/my-40-years-in-the-game-industry
2023-11-03
SEEN
2023-11-01
SEEN
2023-10-30
SEEN
2023-10-29
SEEN
- I followed a small NES programming tutorial (via NESFab). Lots of things are unclear or just alien to me, which is always a bit sad to me, because it clearly shows that the writer doesn’t target people who never programmed 8-bit hardware. I wonder if there’s an absolute in-depth tutorial somewhere that’s also written in an interesting way.
https://pubby.games/nesfab/maze_tutorial.html
https://pubby.games/nesfab/doc.html
2023-10-27
SEEN
2023-10-26
SEEN
2023-10-23
SEEN
- To get the screen size in Godot 4: DisplayServer.window_get_size()
- Viewport size: get_viewport().get_visible_rect().size
- To get the delta time anywhere, use get_process_delta_time() - it’s a global method.
- Watched a video about Godot’s GUI nodes.
https://www.youtube.com/watch?v=1_OFJLyqlXI
DONE
2023-10-22
SEEN
DONE
- After the 2D PacMan prototype in Godot I’m currently combining a Visual Novel with a Dungeon Crawler. This is the prototype of a prototype of course, there isn’t anything in terms of gameplay that makes sense, but it’s another test for me how far I can get in Godot; also this way I try its 3D capabilities, UI and other things.
2023-10-20
SEEN
2023-10-19
SEEN
- How to cast a 3D ray from the current mouse position in GDScript?
var cam := $Camera3D as Camera3D
var mouse_pos := get_viewport().get_mouse_position()
var params := PhysicsRayQueryParameters3D.new()
params.from = cam.project_ray_origin(mouse_pos)
params.to = params.from + cam.project_ray_normal(mouse_pos) * length
var result := get_world_3d().direct_space_state.intersect_ray(params)
2023-10-17
SEEN
- It’s sad that signals and lambdas can’t be static.
- I still don’t quite understand what StringNames (&”foo”) are there for, but apparently they’re better for dictionary keys because they’re quicker to compare.
- elif exists because of the indentation in GDScript code.
- switch is called match here.
- Call breakpoint if you want a Debug.Break().
- assert()s only exist during debug builds.
- x ** y is power.
- Ternary conditions look strange: “a” if cond else “b”. If you want to chain them, use brackets.
- and/or/not instead of &&/||/!
- $NodePath is shorthand for get_node(“NodePath”)
- %UniqueNode is shorthand for get_node(“%UniqueNode”) - doesn’t work outside its scene
- @export to show a variable in the Inspector; @export_range to have an integer in a range
- @onready for being able to use nodes from the beginning
- Use \ for multiple lines
- Arrays use negative indices for counting from the end.
- For large arrays and memory fragmentation concerns, use Packed*Array
- If to avoid an error when accessing a non-existing property, use Object.get()/.set()
- Use := to infer types
- To initialise static variables, use _static_init() instead of _init(). Don’t forget about @static_unload
- You can have getters and setters for variables. Using the property name will access the underlying variable!
- Constant objects, arrays and dictionaries are “flat”. Enums are shorthand for constants.
- a = b = c is not possible
- if “varName” in get_parent(): print(“varName is defined in parent”)
- for i in 3 is short for for i in range(3), which is similar to for i in [0, 1, 2] but without allocating an array
- match can be used on Array patterns and Dictionary patterns.
- Extending from a script can also be done like this:
extends "res://path/to/character.gd" - Use load() to load a script and instantiate from it via new().
- If inheritance is not defined, the class will inherit from RefCounted.
- Add @tool to your script lets it run inside the editor.
- Use await to wait for signals, making the method a coroutine
2023-10-15
SEEN
- I’m currently a bit depressed because the new version of Unity’s navigation mesh package introduced a bug (at least I think it’s a bug) where my NPC would get slower when they approach a wall. It seems Obstacle Avoidance is to blame, because when I deactivate it, the NPC walks narrow hallways as they should, but without it of course it will look strange when there are several NPCs following the player.
https://forum.unity.com/threads/my-navagent-seems-to-try-to-avoid-walls.1506281/
DONE
- I got a bit more into Godot for our small prototype (that isn’t half as finished as I’d like it to be) which was planned as PacMan-like with guns. In any case, I feel much more confident with Godot and GDScript now, but I also think I will use C# again in the near future. Mostly because there are some tools in it that I miss.
2023-10-09
SEEN
2023-09-22
SEEN
2023-09-21
SEEN
- I should write down some of the knowledge I gain from reading A Tour Of C++, just because it’s new to me or I forgot about it.
- Initialising a variable via { } instead of = is preferred because it’s type-checked.
- constexpr allows calling a function during runtime, consteval doesn’t. If you use either, the function is not allowed to have side effects.
- foreach (var x in v) from C# is for (auto x : v) in C++.
- You can do for (auto& x : v) { x = … }
& in a declaration means “reference to”.
* in a declaration means “pointer to”.
& in an expression means “address of”.
* in an expression means “content of”. - Use nullptr instead of 0 or NULL. There is no “null reference”, they always reference valid objects.
- Use import (modules) instead of #include if possible.
- Only use unsigned for bit manipulations.
- Use enum class for strongly typed enumerations, so there is no confusion like with normal enums.
- Don’t use “naked unions”, maybe std::variant instead.
- Use export module MyClass; to define a module at the top of a file.
- using namespace can be used very locally. Don’t use using in a header file.
- Return values can be inferred. Instead if int Function() { } you can write:
auto Function() -> int { }, as it’s more logical. - If a function returns several values via a struct, you can use structural binding:
auto [n, v] = read_entry(stream); // return struct with two members - Use static_assert() to check things at compile time.
- dynamic_cast<>() returns nullptr if the argument isn’t of an expected type.
- Use unique_ptr<> or shared_ptr<> instead of naked pointers; they even make destructors superfluous.
- If a method (member function) doesn’t change its object’s state, declare it const.
void foo() const { … } - A class with virtual functions should have a virtual destructor.
Use override to make overriding an obvious and explicit choice. - Add = default to a declaration to force the standard generation of a constructor. Add = delete to force the compiler to not generate an operation.
- Use explicit in order to hinder automatic conversion due to single argument constructors; use it as default choice and only remove it if really needed.
- Foo(const Foo& a); // copy constructor
Foo& operator=(const Foo& a); // copy assignment
Foo(Foo&& a); // move constructor
Foo& operator=(Foo&& a); // move assignment - Use std::move() in order to enforce the move assignment (instead of getting a copy).
- <=> is the spaceship operator, working similarly to strcmp().
- For a container class Foo to support for (auto& iter : foo) { }, give it a begin() and end() method (cbegin() and cend() for a const container) that return an iterator.
- Implement swap() for sorting algorithms.
- Implement hash<K>() for std::unordered_map<K, V>.
- To automatically have an std::string instead of const char*, add an s to a string (“Hello World”s). A number with an s is an std::second. A number with an i is imaginary, i.e. of type complex. Implement your own literals like this:
constexpr foo<bar> operator””x(int arg) { return { … }; }
2023-09-18
SEEN
- So I tried to check out O3DE, which is basically Lumberyard, which is basically Cryengine. It doesn’t even start the editor for me. Very unfortunate, as nobody in the Discord could help with the problem. It’s not even clear what’s happening here.
- I had another look at Evergine too, and I guess I can survive the “no instant play test mode” thing, but I find it really concerning that it doesn't even have a Discord channel or some other form of community. All I found so far is a repo on github where people can post issues. It’s a bit alienating.
- Unigine’s component system looks good enough for me. Problem with Unigine of course is that it has the same problem as Unity - it’s so proprietary that at any point they could change the pricing and without any source code it’s yet another thing I would get locked in. Also it only supports Windows, basically.
https://www.youtube.com/watch?v=hHcUYQUlG00 - Reading A Tour Of C++ by Bjarne Stroustrup currently, as maybe we will use an engine in the future that demands some C++ knowledge. Last time I used C++ was in 2010, and I was never a good C++ programmer anyway, so this book contains some fun knowledge on the first pages already. For example, I never knew that you can do
if (auto x = vec.size(); x > 5) { … }
in C++. It’s something I actually miss in C# sometimes. And if the check after the semicolon is used for != 0 or nullptr, it can be shortened to
if (auto c = vec.size()) { … } - Defold feels slick, with tutorials built in as small projects. Nice. But it’s actually only for 2D games I guess, and I don’t see a reason right now to use it over Godot, although I like Lua more like GDScript and I like the idea of not having to install additional stuff for building for Android and so on.
2023-09-14
PLAN
- The Unity nav mesh bug I reported finally was accepted as a bug. This is after it was closed before, because the behaviour would be “By Design” (which was a lie). Ugh, Unity. And then this whole thing with the fee for installations, I want to change engine again (some day). The problem is that we don’t know yet what our next project will be. Patou needs to stay in Unity unfortunately. Again, what are my options?
Unreal feels too bloated and I actually want to do smaller projects.
Godot is always so alien to me and feels like it needs more time.
Stride?
Flax is probably “too early”.
O3D?
Heaps again?
Wicked?
Defold?
Armory3D?
NeoAxis? (It’s Russian and that could be a problem. Also not enough platforms.)
Kha?
Unigine? (Looks like Unreal all over again? Also v2 doesn’t have support for mobile.)
Evergine? (No instant testing.)
Raylib? (A bit too barebones probably.)
FreeBasic? (Haha.)
Wish I knew how to create my own custom engine without spending too much time on it.
2023-09-03
SEEN
DONE
2023-08-29
DONE
- As I’d like to do more low-level stuff (DOS programming, maybe Arduino) and recently learned about Exercism, I tried some of their exercises. So far I like it a lot, I had three different mentors for several small tasks and they always were helpful and deepened my knowledge about C.
https://exercism.org/profiles/ratrogue
2023-08-25
SEEN
2023-08-12
DONE
- A lot has been done but not talked about, for Patou. We’re preparing the current version for the devcom, and while I’m not overly confident (as usual) I try to cram enough things into it to make it shine a bit. A new debug menu for teleporting, collectibles (dog treats, flowers) that can be used as secrets in each level, special animations like sitting on benches for Kit, the Sphinx appearing during dialogs, a simple intro text, bug fixes, and so on.
2023-08-01
SEEN
2023-07-31
SEEN
2023-07-29
SEEN
2023-07-24
DONE
- While trying to fix annoying glitches in Patou especially regarding nav meshes and off-mesh links, I noticed that, when changing the nav agent’s position per frame during the traversal of an off-mesh link, I also should directly set the agent’s velocity to prevent an ugly break in the path by the dog.
2023-07-22
SEEN
2023-07-19
SEEN
- For Patou I’m still searching for a pipe tool - because we want to show that puzzle elements are connected to each other (a trigger activates an elevator, etc.) and everything else - wires, particle effects - doesn’t quite fit with the style and world. Instant Pipes seems like it fits the bill quite nicely, it looks good and is easy to use.
https://github.com/leth4/InstantPipes
2023-07-18
DONE
- In preparation for the devcom I updated our website a bit, mostly removing an old project, changing the banner pictures, more focus on Patou and replacing Patou’s screenshots. Hopefully I’ll remember that I hardcoded the project with the modal ID 2500 to be always at the top, as our current WIP project.
https://ratking.de/
https://gohugo.io/templates/introduction/
2023-07-11
DONE
2023-07-10
DONE
- I had some serious problems with ABGEFAHREN’s character controller. I use the one I made aeons ago for my jam needs and never really touched it again because it most often worked “well enough”. So when Stepahn couldn’t even rotate the player on his Mac I thought I should dig into it a bit and try to fix the most annoying parts. Mostly it turns out that I rotated the player transform and that was a bad idea because in combination with a RigidBody that can lead to unexpected behaviour.
https://ratking.itch.io/abgefahren/devlog/558342/small-but-important-fixes
2023-07-09
DONE
- Over the weekend we created a game for the bpb game jam 2023. With “we” I mean Jana and I and three other people (plus Crabman doing the music). The theme was Mobility. This was the first time that I was in a team with two programmers, and it was quite an interesting experience. I am also happy about our creation, as it became pretty atmospheric and full of potential for interesting content. ABGEFAHREN recreates the experience of travelling per train in Germany.
Pretty much all the other entries are great too - this was truly an inspiring event.
https://itch.io/jam/bpbgamejam-2023/entries
https://ratking.itch.io/abgefahren
2023-07-06
SEEN
2023-07-04
SEEN
2023-07-02
SEEN
2023-06-26
SEEN
2023-06-12
SEEN
- I’m more and more convinced that Character Controller Pro is the most stable and usable character controller asset for Unity right now, at least for me. Maybe I’ll use it for Patou (or rather Kit) later on - but right now we’re concentrating on getting a new version ready for the upcoming Devcom.
2023-06-03
SEEN
DONE
- I experimented a bit with small3dlib and TinyPTC, using it with DOSBox by compiling a small test case (a single triangle) via DJGPP. I had a lot of strange bugs with variables not even working correctly, and I feel like giving up, because apparently C is dark magic. Combine that with the fact that 3D stuff will always have bad performance if using libraries like that, I definitely go in the wrong direction, even if I just want to do something simple like a gridder.
https://gitlab.com/drummyfish/small3dlib
https://sourceforge.net/projects/tinyptc/
2023-06-01
SEEN
- I read this short tutorial about Unity’s inbuilt object pooling system. I might use it someday, as I think my own solution isn’t the best. Pooling is such a crutch, just because you have to know what a Garbage Collector is and why it has its problems; I guess everything comes with advantages and disadvantages.
https://unity.com/how-to/use-object-pooling-boost-performance-c-scripts-unity
2023-05-30
DONE
- Recently I got interested in FreeBASIC, and how I could use it to target both Windows and DOS. I found a version of TinyGL for FreeBASIC, but I had to compile the library myself so it would run in DOS. Even TEST01.BAS is unfortunately quite slow, 8fps with only three triangles shown. I don't think I want to put more time into this, but it was an interesting excursion.
https://mstdn.io/@ratking/110459022509065635
2023-05-25
DONE
- After a power loss somehow the git repo of Patou was broken again, it showed DETACHED HEAD and there was no way to reattach it, at least not inside Fork. The solution was to manually edit the files in .git/ref/heads and .git/ref/remotes/origin so they would contain the correct SHA again. What a waste of time.
2023-05-24
DONE
- Yet again I had to fix a bug in the Wordpress theme Blogrid, because the creators didn’t include the fix I sent them. In the file inc/template-tags.php, there’s a missing “$byline .”, which means the author is never displayed.
2023-05-23
SEEN
2023-05-21
SEEN
- Funny little tidbit I came across today - in ugBASIC, the keyword FUNCTION is defined, but subroutines/procedures actually only use PROCEDURE and GOSUB. Apparently this keyword isn’t used at all. I wonder if there are more of these. In any case there are a lot of keywords in ugBASIC where I think this should be defined differently, especially a lot of music instruments.
https://retroprogramming.iwashere.eu/ugbasic:syntax
DONE
- Last week I had to create a video with gameplay from Patou. Well, it wasn’t really an absolute must, but I got interviewed by ludipe, for the AstraFund, and I wanted to show some of the “thinky” parts of Patou. Of course, nothing worked, because we did stuff for the AMAZE demo the days before and changes were made that affected the puzzle levels. So afterwards I fixed it and sent him the promised video, hopefully redeeming myself. It felt good, even though I’m sure I won’t be selected for the Fund.
2023-05-20
SEEN
2023-05-19
SEEN
- I finally discovered the NavMeshModifier component that excludes game objects from the navigation mesh creation in Unity. I had a problem with it not working for some objects, but then I read that the layer must be right too.
https://forum.unity.com/threads/navmesh-modifiers-are-completely-ignored.676369/#post-7854210 - I’m done with reading the C book, and it feels so archaic and alien sometimes. I won’t need most of the stuff, but still it was good to get into the way of thinking again. Somehow I missed this.
2023-05-15
SEEN
- I’m currently reading a book about C, and I didn’t know that C11 allows some kind of generic functions, by using the _Generic keyword. I’m really eager to try some low level programming for a small dungeon crawler project.
https://en.cppreference.com/w/c/language/generic
DONE
- We’re back from the AMAZE, where we showed Patou for a few hours. Overall it was a very positive experience, but of course it also made clear how much more work there is to be done, in every department.
2023-05-03
DONE
- After hunting another strange bug where an animation would not get played but only if the player comes from another scene, I should remember this: always make sure that everything is initialised BEFORE the component’s core functionality is used. In this case the Start() method would reset the animation, as the object was hidden until then.
2023-05-01
SEEN
- I was visiting the Indie Outpost in Nuremberg today, and someone held a talk about Godot. It was pretty negative towards Unity, but the guy was showing a few tools he uses and one of them was Dotgrid, which I never heard of before. It looks interesting, a vector art tool specifically for logos and icons and maybe more.
https://hundredrabbits.itch.io/dotgrid
DONE
- Version 0.8.0 of connected adds the Search Phrase tool, which is pretty much the last feature that was missing from the original Moritalk and that I wanted to have in again in any case. (The Node Flow functionality and the Dialog Border are definitely not as important, but would be nice to have.)
https://mstdn.io/@ratking/110292550876345626
2023-04-28
DONE
- I was hunting a bug with connected - a dialog file for Patou would have two nodes with the same ID; which is not allowed to happen. (Also only in the game file, not in the editor file.) So I investigated for quite some time, but in the end I had to conclude that this happened due to a badly solved merge conflict, because I could not find a way to replicate it.
2023-04-22
DONE
2023-04-19
SEEN
PLAN
- While I didn’t submit anything to the Dungeon Crawler Jam 2023, I feel like the project I did could have potential so I currently plan to create a story for a potential “real” crawler and just try it out. As Jana still is not interested in a gridder I might try finding another artist for this.
DONE
- It’s not really newsworthy, but I wanted to add something to the Patou blog at least, so I wrote about the start menu screen I worked on for a day. I liked how we did it in TRI, loading a real level into the background, so I did that again.
http://ratking.de/patou/2023/04/19/start-menu/
2023-04-15
DONE
- I made another update for connected, as there were some serious bugs and flaws, so now it’s v0.7.2. I also took the opportunity to add a quality-of-life feature - finally, duplicated nodes will be positioned at the right position: under the mouse cursor.
https://ratking.itch.io/connected/devlog/517016/connected-v072
2023-04-14
SEEN
- I tried to rename several files in several subfolders. They had the form “nostalgia_100_ghost_bury” and I just wanted to replace the “nostalgia” with “nost”. So via startpageing I found a piece of command line code that allegedly does what I want:
for /r %x in (nostalgia_100_*.*) do ren "%x" nost_100_*.*
But that didn’t quite work. It renamed the files to something like “nost_100_gia_100_ghost_bury” - and nobody else seems to have that problem. So I resorted to ChatGPT which told me to use PowerShell instead and this script:
Get-ChildItem -Path .\ -Recurse -Filter "nostalgia_100_*.*" | Foreach-Object {Rename-Item $_.FullName -NewName $_.Name.Replace("nostalgia_100_", "nost_100_")}
And that actually worked.
https://stackoverflow.com/questions/245840/how-do-i-rename-files-in-sub-directories
2023-04-13
DONE
2023-04-09
DONE
- I did a first iteration of the prototype for a visual novel that might or might not happen, together with a guy named Baddy. Right now I’m only testing the dialog UI, so pretty much the same as with Patou. The most interesting result so far is that adding connected is a bit complicated when not using the provided example dialog code, so I will have to look more into making this easier, I guess.
2023-04-08
SEEN
DONE
- As I did a bit of “sound design” for Ghost in the Paint, I uploaded a new version with footsteps, wind ambient sound and a wobble effect I made with Helm. I actually don’t know how to create sound effects that aren’t natural, so I want to look into this a bit more.
https://tytel.org/helm/
https://ludwig-hanisch.itch.io/ghost-in-the-paint - While working on my dungeon crawler I noticed a bug in SBT, which caused some strangeness with the first few ticks. Which means it would only be obvious when SBT is used in a turn-based game. Fixing it was just a matter of initialising a variable differently, phew.
https://github.com/ratkingsminion/simple-behaviour-tree
2023-04-07
DONE
- I participated in the Dungeon Crawler Jam 2023, but I didn’t finish my entry, because half-way through the last day I noticed that I wouldn’t have time to make something complete and interesting. I’m kind of proud of what I achieved though, because as I re-created my usual stealth gridder project I found some ways to make it work. So maybe I will continue with this, in some way.
https://mstdn.io/@ratking/110157354068685494
2023-04-03
DONE
- I finally created that video I wanted to make for applying at Astra Fund. While I don’t think I will receive it, as I’m too old for this, it was kind of a good exercise to do this retrospective. The low view count though shows me yet again that I’m probably in the wrong profession altogether.
https://www.youtube.com/watch?v=IRumvZbGHEk
2023-03-31
DONE
- I uploaded a new version (v0.7.0) of connected, which finally supports node type definitions from the outside (via JSON and C# files). All that's missing is some documentation for that. Additionally there's now a free lite version which does not allow new node type definitions and also does not generate a separate file for texts, but otherwise has the same functionality.
https://ratking.itch.io/connected/devlog/510360/connected-v070
2023-03-30
SEEN
- Useful tip for the future, when using git and Unity: Place a .gitattributes file into the folder with all lightmap textures and light probes to override the root folder setup, with *.asset binary as content. The root folder contains the line *.asset text eol=lf. I’ll have to check how to combine this with LFS.
2023-03-26
DONE
2023-03-25
DONE
- Finally I removed Small Basic from connected and replaced all the configuration code for the nodes with C#, of course fed to the Roslyn compiler. I even fixed some issues I was having with connection order being lost when changing a node that would reset its contents. One wrinkle is still there: if there’s a variable amount of connectors, like with the Switch node, the connections can get completely lost on undo actions.
2023-03-24
SEEN
2023-03-22
SEEN
2023-03-21
DONE
- I uploaded a version 0.4.0 of Ghost in the Paint, as I could bring the gallery level to a playable state. The second level isn’t interactive at all yet, but that will come with the next update, probably in a month or later. Also, sounds.
https://ludwig-hanisch.itch.io/ghost-in-the-paint
2023-03-20
- While the C# support for the configuration of node types is still in the works, I made a new version of connected because I noticed some bugs. Also I had to finally add the path settings to the Settings menu because this week connected will be used by all Patou team members to create some fake dialogs.
2023-03-19
SEEN
2023-03-18
DONE
- Another new version of connected uploaded - it’s still not a release candidate, but I could add some small but important features (like the display of an out connector’s connections order) and a welcome screen (with a list of files recently opened and an online version check via itch.io). The next big steps for an actual release are an integration of options (with a JSON file) and switching the configuration scripts for the nodes from Small Basic to C#. After that it’s all about creating a free (lite) version and a commercial (pro) version. The plan is that the pro version allows changing and adding node types, and saving texts in an extra file (which already works, so I actually have to “remove” that feature for lite only).
2023-03-16
DONE
- The interaction hints in Patou got improved. Instead of just showing “E - Interact” it now actually says which object/NPC the player currently can interact with, and what this interaction is (picking up, talking, unlocking, etc).
2023-03-15
DONE
- I upgraded Patou’s dialog UI a bit. It’s based on our intern Patrick’s design - he actually created the UI in Unity too, but unfortunately it would be too static for my taste. So basically I only took some inspirations from it, like the wobbly outline, and tried to fit it into something that can have different text lengths and amount of player choices. Of course NPC texts that are too long will still be cut off (because I really don’t want scroll bars in this case, especially if we have voice overs), but if there ever is a reason to support text walls - which we hopefully won’t, because they’re boring - there will be a simple solution ready by just splitting the text in two or more parts. Anyway, it’s still a problem that UGUI doesn’t quite well support giving elements a maximum size, and the solution I have is a bit hacky, but at least it works.
2023-03-13
DONE
- I think I could solve most of the problems with connected’s Test Mode, so I uploaded a new version. The nodes are not dynamic yet, but the code now supports that. A bit of a problem is that I can’t just add C# code files as text assets to be referenced in a script, but that problem should be temporary. The question is if I will jump the shark and replace all the SmallBasic code with C#...
2023-03-12
SEEN
DONE
2023-03-11
DONE
- I added a useful zoom menu to connected, so it’s now version 0.5.4. And I’m on the path to bring back the Test Mode. Right now it’s mostly a copy of the old legacy version, so it’s not dynamic yet, but I plan to use the Roslyn compiler next.
https://mstdn.io/@ratking/110006452968350739
2023-03-10
SEEN
- TIL that a GameObject that was never active and gets destroyed doesn’t call OnDestroy() on its children. Strange but true. At least I could fix that null ref error from yesterday.
DONE
- Uploaded the new version of connected with the correctness check. Next step obviously is to finally use the new format with Patou and make it the “official” version.
2023-03-09
SEEN
DONE
- I re-added the correctness check to connected, and also fixed a pesky bug that would prevent saving variables that are not bound to an element of a node (for example, the number of cases in a Switch node). As soon as I find the reason why the connections sometimes create null reference errors I will upload the update.
https://mstdn.io/@ratking/109995638236707384
2023-03-07
DONE
- The fifth episode of our Patou dev log is exclusively about the visuals of the dog. So the next part might be about dog gameplay. Hopefully this won’t be too awkward, I’m still far from confident about showing it around, but it has to be done either way.
https://www.youtube.com/watch?v=39_daYk6B0w - I’m finally continuing to work on Ghost in the Paint by adding some screenshake, an in-game menu (with an options screen) and the ability to change the level after the Black Gate. It’s probably a long way till it’s finished, of course; so it’s not yet updated on itch. Before there’s an official update I have to improve the second level (the gallery) and add some kind of ending. Sounds would be great too.
- I updated some of my open source libraries (as I needed some additional functionalities) in the last few days; there’s now a hotkey analyzer in the Game Jam Base Code and also sounds can follow a transform, and for SIH I added temporary schemes (only if you use Rewired). Oh, and already for some weeks now SUS can be used outside of Unity.
https://github.com/ratkingsminion/game-jam-base-code
https://github.com/ratkingsminion/simple-input-helpers
https://github.com/ratkingsminion/simple-utility-system
2023-03-02
DONE
- I updated the new version of connected, adding confirmation dialogs and doing a few small bug fixes. Next up I should do Patou supporting the new format, and then it will be the actual main dialog editor for the future, probably.
2023-03-01
SEEN
2023-02-26
SEEN
2023-02-25
DONE
- When we showed Patou at the Gamedev Meetup in Leipzig, I noticed that the Speedlines effect wouldn't appear in the build (only in the editor). I actually had this problem before, but the reason was something on my side. This time it definitely was something with SCPE, probably since the last update. After a very long debug session, where I would change the order of post-effects, remove some, and do a lot of other things, I finally found the alleged culprit: Only if the toggle is ON for the Noise Tex - no matter if the actual texture is changed or not - the effect would show, otherwise it never appears. My guess is that Unity somehow thinks that the texture is not used if the toggle is off and doesn't include it in the build. Anyway, this took way too long, and I hope there is some kind of fix for this.
- A student who does security stuff on the side mailed me because of a potential security flaw on my website. I was a bit shocked, but it wasn’t really my website but the blog that I wrote for my graduation project (Schwere in der Schwebe / Hals über Kopf) 13 years ago. My PHP game was never really strong, so I never expected it to be the best thing ever. In the end it was “just” a flaw that other people could use an URL of my blog to gain access to another person’s computer (i.e. XSS), so all I did now was make my blog a static HTML website, by removing some dynamic stuff (especially the tag selection) and then using HTTrack to crawl it on a local webserver (XAMPP). Also, the student wanted some money for him finding the bug, but to be honest this actually caused me quite some stress and I don’t have much money anyway, so I refrained from that.
https://www.fholio.de/archive/sids/
2023-02-24
DONE
- Conclusion from tonight’s Gamedev Meetup Leipzig, where we showed Patou on a laptop: As expected, not many people dared to actually try it out (only 3 people in total - it’s a pretty small meetup), but it was more than enough for feedback. Overall we left with a positive feeling, people thought it was pretty and above all somewhat unique. The digging is the main problem right now, too much has to be explained when people try it out.
2023-02-18
SEEN
- The Uxn ecosystem looks fun, somehow. It’s appealing because of the simplicity.
https://100r.co/site/uxn.html - In Unity, I really need to remember how to set the layout for a vertical list of buttons with different/dynamic heights based on their text contents. (Mostly important for Scroll Views.) First step is to add a Vertical Layout Group on the Content panel (Control Child Size Height toggled on and Child Force Expand toggled off) and a Horizontal Layout Group on the Button (same toggles). The Content panel also gets a Content Size Fitter with Vertical Fit set to Preferred Size. The text element of the button doesn’t need any additional component.
DONE
2023-02-17
DONE
- I will rename Terrobot X to Games for Rats, because Terrobot X itself is another project altogether. Anyway, I made the log output much nicer, and it even jumps to the faulty line when the user clicks on an error. Also it’s now possible to change the “screen resolution” by using Small Basic, and soon there will be more options available. Before I do a soft release I want to have screen focus (so you don’t manipulate both the editor and the in-game controls at the same time anymore), and a rudimentary welcome screen.
2023-02-14
DONE
- Some more work on Terrobot X - I copied connected’s top menu bar and reused it for this project. I’m also working on the API now, which hopefully will soon allow some interesting experiments with variable screen shapes.
https://mstdn.io/@ratking/109865113821737902
2023-02-12
DONE
2023-02-11
DONE
- I uploaded a new version of bloed, mostly with hotfixes for bugs that I noticed during making Root 666. But Tom ‘voxel’ Purnell also allowed me to add the textures he made for 666 Coins; this way people are quicker in creating something with the tool out of the box.
https://ratking.itch.io/bloed/devlog/488499/bloed-v113
2023-02-10
SEEN
- Somewhere I saw this construct: public ref Character Character => ref _Character;
… and if I understand the ref modifier correctly I don’t really see how this is any different from just having a public Character variable, other than making it more complicated? In any case ref return is something I should try to use sometime; should be useful with array stuff and when returning big structs.
2023-02-09
DONE
- While working with bloed in Root 666 I noticed that the old bug with the Tab key was occurring again and I wondered why. Today I dug into it and it was an easy fix - I used #define UNITY_2021_OR_NEWER instead of the correct UNITY_2021_1_OR_NEWER. I really think they could just add both.
2023-02-06
SEEN
DONE
- I did a small update for Root 666, as there were some annoying things that happened (and were released) because of the time constraints of a jam. But now the enemies can hit the player when they’re fighting on a slope, and you can exit the game via Escape. Also, Jana made a video of the gameplay.
https://ratking.itch.io/root666/devlog/486493/version-03-for-root-666
https://www.youtube.com/watch?v=AcviSew1V1Y - As I stumbled over a somewhat strange edge case while doing behaviour trees for the enemies in Root 666, I finally looked further into the issue and actually I was just using the InsertTree() method of SBT in a wrong way. But instead of adding a note about the correct usage to the docs I just allow the incorrect usage and therefore make it correct usage. Basically a tree can now have more than one root (how fitting for the GGJ theme!) and this way InsertTree() can be used more dynamically.
https://github.com/ratkingsminion/simple-behaviour-tree
2023-02-05
DONE
- Jana and I participated in the Global Game Jam for the ninth time, so the next one is a jubilee! This time the theme was “Roots”. With the help of Norrimo (Patrick Eckardt), mostly in the music department, we created a horror game where you throw screaming mandrake roots and hit enemies with a stick that has an eye stuck on it. Jana used bloed to make the level, and I got to use my fluent behaviour tree C# implementation for the first time. Of course a lot of bugs became apparent this way, but in the end we actually finished our entry Root 666.
https://globalgamejam.org/2023/games/root-666-0
https://ratking.itch.io/root666
2023-02-02
DONE
- Just encountered an annoyance with the Patou project - after a ruin would emerge and change the navMeshData, the changes would persist on the hard drive. That’s pretty bad. After trying different things, I concluded that only this code seems to help:
var copy = Instantiate(surface.navMeshData);
surface.RemoveData();
surface.navMeshData = copy;
surface.AddData(); - Some more work on Terrobot X, with a name change soon hopefully. Anyway, I made the layout resizable, which was relatively easy thanks to UGUI’s layout system.
https://mstdn.io/@ratking/109797230691527241
2023-01-31
DONE
2023-01-30
SEEN
2023-01-29
DONE
- I had some strange issue with my input strings in Terrobot X, where sometimes some keys wouldn’t show up in the text field. Only a lengthy debug session would make it clear that using Update() for input handling leads to the return key sometimes overwriting what I type. So I had to switch to OnGUI() and handle key events manually. Probably the better way in the end, but this also has some quirks (like a key event would fire twice, once with the character and one with the KeyCode).
2023-01-28
DONE
2023-01-27
SEEN
PLAN
- We’re going to participate in the Global Game Jam again, although in a very constrained and small manner. Basically it’s just us and another office (Prefrontal Cortex) in the same building (MMZ).
https://globalgamejam.org/2023/jam-sites/ggj-halle-rat-prefrontal-king-cortex - A year ago I worked on Terrobot X, and unfortunately it never became what it was meant to be (an extended version of the first-person gridder programming jam game), but at least the code editor I made was mostly working. I never used it for anything though, I streamed a bit and that was it. Now I want it as the basis for a fantasy console (which I already planned back then too), especially for simple entries for the One Hour Game Jam. I would be able to extend the console itself from time to time while still having all the entries inside; well, that’s the plan at least.
https://onehourgamejam.com/
SEEN/DONE
2023-01-24
SEEN
2023-01-22
SEEN
- Interesting but short article from 2006 about how the original God of War was developed, as there was some kind of conflict between the lead designer (who wanted “all special cases”) and the programmers (who think of special cases as their natural enemy). The executable was only 1.5 megabytes big!
https://www.gamedeveloper.com/design/gdc-i-god-of-war-i-how-the-left-and-right-brain-learned-to-love-one-another - I finally tried Evergine (which was Wave Engine before), and it doesn't seem to have any kind of play mode, so you have to build in order to test the game. I guess it's retro. Call me entitled, but if I could work without instant testing I would just use Heaps or Raylib.
https://evergine.com/
2023-01-21
SEEN
- Just had a serious bug with closures, serious because it was hard to track down. Basically a closure gets generated each time so if you store it in a variable and compare it later again the result is false instead of true, because it’s actually not the same object. Which makes sense of course.
2023-01-20
SEEN
- I read this short tutorial about how to create a “see through” effect for characters in Unity URP. Could be useful for Patou, but I actually don’t like that it (of course) does that for everything at once; for example if only the protagonist’s feet are hidden by some floor plate, it’s jarring.
https://docs.unity.cn/Packages/com.unity.render-pipelines.universal@11.0/manual/renderer-features/how-to-custom-effect-render-objects.html - We did another video for the Patou vlog, this time about the portals. The video is pretty short, mostly because I forgot to mention some stuff, like how the flowers and trees are using instanced mesh rendering and are actually placed directly on the terrain.
https://www.youtube.com/watch?v=S8hRFF_ZfzA - I followed another tutorial about custom effects, because I wanted to know how to create post processing effects with URP. Turns out it’s even more of a hassle than I thought, at least according to this tutorial. Just the simple effect of having a colour overlay has several scripts with a lot of hard to understand boilerplate code. And it doesn’t work with another effect (by SCPE), as it gets removed by the Black Bars post effect. Ugh.
https://www.febucci.com/2022/05/custom-post-processing-in-urp/
DONE
- I’ve done quite a bit of work on Patou, mostly on the cutscenes. I call the scripted sequences and they are probably both under and over powered, as they are hard to set up for the creator but also are pretty extendible. So I guess they’re mostly perfect for me, and not so much for any artist working on the project. It would be nice to have some kind of preview feature, but overall I don’t expect that we have too much of them.
2023-01-15
SEEN
2023-01-12
SEEN
- Today I learned that C#’s HasFlag() method for enums uses boxing and therefore allocates memory! Ugh.
2023-01-09
DONE
- I found a serious bug in my behaviour tree implementation, where Repeat and Retry nodes could lead to nodes being processed and executed more than once during a tick, which is obviously bad and even creates endless loops. I fixed it with a tick counter, which looks a bit like a hack, but I guess it does make the implementation more foolproof, especially if I ever add more node types.
https://github.com/ratkingsminion/simple-behaviour-tree
2023-01-07
PLAN
- I had an idea for a code ping-pong, but it wasn’t received with approval, so here it is, for archive reasons, and maybe I’ll come back to it later:
Basically a ping-pong based on levels. The participants start with a simple arcade game base mechanic, for example Pac Man guy with Pac Man movement. First participant A adds a level with the player having to collect pellets. Then participant B adds a level with a simple enemy, with the pellets. After that A adds a level with moving platforms; and so on, until the last level doesn't even resemble Pac Man anymore maybe, or it's just Pac Man on steroids. There could be some ground rules like "the level has to reuse at least half of the features from the levels before", or "the basic player movement is not allowed to change, so it's always controlled by the arrow keys only".
Of course each feature would need to be documented clearly, and it should be very easy to add a feature to a level.
2023-01-06
SEEN
2023-01-05
SEEN
2023-01-04
SEEN
2023-01-03
SEEN
- So it’s possible to speed up the Play mode of Unity significantly, but it comes with a big caveat. Via unchecking “Project Settings → Editor → Enter Play Mode” Domain and Scene are not reloaded anymore. It also means it doesn’t reset static variables to their initialisation values, which can be quite annoying. But I guess this can be counteracted via a static method with the RuntimeInitializeOnLoadMethod attribute. I have to check if this is viable.
https://www.youtube.com/watch?v=wRCnKtpzf5U
https://blog.unity.com/technology/enter-play-mode-faster-in-unity-2019-3 - I finally watched Freya Holmer’s video about splines; it’s a very good introduction into the subject, and also has in-depth explanations and, of course, extremely good animations. Her maths helper collection should be helpful too in the future.
https://www.youtube.com/watch?v=jvPPXbo87ds
https://github.com/FreyaHolmer/Mathfs - I watched this introduction video to Super Netcode. Looks quite easy (the devil is probably in the details). Though getting people from across the planet to join a networking session will still be a problem I’m sure - a relay is needed for that (e.g. via Steam or Photon) - and, well, friends. Anyway, someday I will try a multiplayer game again, just for fun.
https://www.youtube.com/watch?v=Odn1MQo6V_k
https://assetstore.unity.com/packages/tools/network/super-netcode-175227 - MonoBehaviour Systems - more DOTS stuff, this time combining it with MonoBehaviours so maybe I don’t have to give up my comfort zone completely. In any case I should look more into it.
https://www.youtube.com/watch?v=RhU8NZtgYp0 - More things using DOTS with GameObjects. I love how such posts always talk about how easy this is, but the code always looks like a mess to me.
https://coffeebraingames.wordpress.com/2021/11/23/the-safest-way-to-use-dots-in-your-monobehaviour-project/ - I also want to find out more about DrawMeshInstancedIndirect() to be able to have more meshes on the GPU instead of the CPU. These articles help a bit.
https://toqoz.fyi/thousands-of-meshes.html
https://coffeebraingames.wordpress.com/2022/10/04/sorting-a-million-sprites/ - So actually there is a (very convoluted) way to have custom lighting in URP! It only really works with ShaderGraph though, it seems, and for hand written shaders there would be other steps. Thanks to this tutorial I also learned about ScriptableSingletons in Unity.
https://bronsonzgeb.com/index.php/2021/10/04/custom-lighting-in-urp-with-shader-graph/
https://bronsonzgeb.com/index.php/2021/10/11/custom-lighting-in-shader-graph-part-2/
https://docs.unity3d.com/2020.1/Documentation/ScriptReference/ScriptableSingleton_1.html - A breakdown of how AAA clouds are done in games, via ray-marching and SDFs.
https://www.youtube.com/watch?v=Qj_tK_mdRcA
2023-01-02
SEEN
2022-12-30
SEEN
- Unity supports proprietary 3D model formats like .max and .blend if the programs are installed. I thought I had Blender correctly installed, but apparently Unity doesn’t find it if it’s installed via the Microsoft Store … a bummer. (It’s not recommended to use .blend files in a Unity project anyway.)
2022-12-25
SEEN
2022-12-23
SEEN
2022-12-22
DONE
2022-12-16
SEEN
2022-12-14
DONE
- I wasted a lot of time today finding out why I get thousands of “Failed to unpersist” errors when stopping the play mode during Patou development. This only happened when starting with certain scenes, in a certain order, with a certain scene being the active one. Really strange and esoteric. In the end I had two options: remove the Volumetric Fog from that scene (because then the error wouldn’t appear), or find out what is actually causing it. I could pin it down to a prefab that had a PolyBrushMesh component attached to it, and thankfully that one was not necessary. Still, what a strange bug, and hopefully it’s not coming back.
2022-12-12
DONE
2022-12-11
SEEN
DONE
2022-12-10
SEEN
- As I’m doing the PICO-8 jam next weekend I’m preparing by watching some videos. This one is very interesting, because it improves the workflow a lot. I should remember how to do the debugging by using printh and tail, and that you can #include Lua files.
https://www.youtube.com/watch?v=srPKBhzgZhc&t=918s
2022-12-09
SEEN
- Watched this interesting breakdown of Zelda: Breath of the Wild’s render pipeline - because there is a strange graphics bug in a certain situation, people wondered why it happens, and this video gives a very long and thorough answer.
https://www.youtube.com/watch?v=By7qcgaqGI4
DONE
- I extended the shader for Patou’s floor fog a bit, so now it allows creating a “hole” inside a certain boundary. For that you need a manager, as the boundary changes per sub level of course.
https://mstdn.io/@ratking/109485341899048091
2022-12-07
DONE
- Not much to report these days, as I’m working on Patou, steadily, but with many smaller tasks not really worth talking about. For example, the tool that I created to be able to make barriers is now more usable, and I actually reuse it for creating “sound lines” - lines where a sound source can move along, which is useful for rivers for example.
Then I changed the barriers so that they don’t just make a big mesh collider, but box colliders along each segment. Now those are triggers which repel the player walking in by turning them around and moving them a bit back. This led to improving how the whole “warping” works a bit, because otherwise the player, especially the dog, would behave wrong.
2022-12-04
SEEN
2022-12-01
DONE
- I will never be comfortable with such a format, generally with talking into a camera, but we did a short development video about Patou, something we want to do more regularly from now on.
https://www.youtube.com/watch?v=nQBG5XqHKAw
2022-11-30
DONE
- My brother and I soft-launched the Ghost in the Paint space today, which has roughly half of the planned content. The file got very big, so there is no WebGL build anymore. Though I’m satisfied with how much I could get done within a few days.
https://ratrogue.itch.io/ghost-in-the-paint
2022-11-28
DONE
- While checking on the profiler while working Patou I noticed that there was an Update() method that would create 80 bytes of garbage every frame, but inside I couldn’t find out at first what was leaking it - no foreach, no string, nothing. Only later I noticed that I had a closure (a lambda that would use a local variable) inside an if() that only was true in rare cases - yet the closure was generated every frame. Gotta be more careful in the future…
2022-11-25
SEEN
2022-11-23
SEEN
DONE
- I sometimes have static variables in my Unity components that I set once to initialise some stuff, and then would like to reset them when the game restarts (without restarting the whole application, that is). So I wrote an attribute that helps in this regard. Reflection always feels a bit icky though.
https://gist.github.com/ratkingsminion/d867cb556ec0f03ccacc2674c6b6c276
2022-11-20
SEEN
- A video about pitfalls of generics in C# and how to use them in an allocation-free way. Not bad.
https://www.youtube.com/watch?v=YAOqHj1cUaQ - I really like the light hearted world of Alba, so I enjoyed this dev video about how they approached the open world in Unity. Some interesting take-aways, like how they had to change the trees to a much simpler style because imposters with lots of alpha would crash the performance on mobile platforms.
https://www.youtube.com/watch?v=YOtDVv5-0A4
2022-11-18
SEEN
2022-11-17
DONE
- We showcased Patou once again, at the GameDev Leipzig MeetUp - just my laptop and a gamepad. The few people (it is a very small meetup) who played it mostly liked the music and sounds and also the style of the landscape. The current prototype/game only consists of the “overworld” - the place where you ride on the dog and later on try to find buried memories (which will be small-ish separate scenes). There are some issues with the dog’s movement, but overall I think it works well enough and there were no big bugs. Some performance hiccups though. I am glad we took several steps back and now work more focused on single game elements, in this case the riding and the overworld. It’s just much more motivating.
Most of the work the past week went into this version for the meetup. I wrote a very simple tool that allows me to create a barrier (so people don’t walk outside the terrain). A lot of sounds were added, for example water splashes and their particle effects. The kamis from TRI are back somehow (I reused their spline code at least), and now they help the player to find the memory islands.
2022-11-13
DONE
- For Patou I’m currently trying to bring the screen space fog effect that we use for most of the scenes to transparent materials - just because we will have so many of them. My approach is to copy the whole URP folder from Unity (putting it into the Packages folder) and later on change the MixFog function for the shaders. At first I had a lot of pink materials, but it turned out that I just needed to re-import most of the shaders inside the project. Now onto the actual fog change. But in any case the current version looks already somewhat presentable.
https://twitter.com/RottenHedgehog/status/1591777299959279617 - Added a bit more interactivity to the Ghost in the Paint project; you can now drag down a basketball basket (with a Dreamteck spline). Next on I want to display some text in a Zelda fashion when you interact with the basket.
2022-11-10
SEEN
- Re-learned today that a particle system in Unity does not get automatically destroyed unless the emission module’s enabled parameter is set to false, the main module’s stopAction to ParticleSystemStopAction.Destroy and its loop parameters to false. The last one was what I was missing.
- Another learning: grass on the Unity terrain looks bad in the distance as long as the mip-map settings are suboptimal - one has to set Mip Maps Preserve Coverage to true, and the Alpha Cutoff Value that appears to a value between 0 and 1. But! Setting it to 1 is the same as 0 - so you actually have to change it to 0.99 if you want full coverage.
2022-11-07
DONE
- Implemented copy & paste in the new version of connected. This might sound easy enough, but there are some pitfalls that I had to consider, so it’s not like I can just call Instantiate() and be done with it. For example, I actually have to make sure the copied nodes don’t use the current localised text data (as that one is serialised separately and can change in the meantime), and copied nodes can be pasted even if the user clears the current canvas.
2022-11-04
SEEN
- Reminder to myself: when adding a webhook from Discord to Github, don’t forget to add /github to the secret URL.
DONE
- We’re trying a new-old direction for Patou and getting back to terrains. It’s instantly nicer to look at than our Blender levels, mostly because we can iterate faster; but overall it’s missing a bit of personality though, at least in my opinion. In any case I currently want the player to switch between an “overworld” and different “small islands” which would host the ruins and their puzzles (if there are any). This overworld should only be accessed by riding the dog, and automatically left when unmounting him. This might give it a nice pacing.
- I uploaded SIH, Simple Input-related Helpers, on Github. It’s a small collection of input wrapper scripts for Unity that I seemed to write again and again, so here’s something reusable (untested). With these scripts I can easily add delayed input to interactable objects, making behaviour in the vein of “tap E to consume item; keep E pressed to collect item” possible. The system is for Unity’s legacy Input Manager, but also for Rewired. Unity’s new Input System works very differently, which is why SIH doesn’t support it (yet?).
https://github.com/ratkingsminion/sih
2022-11-01
DONE
- Today I gave another Unity course, again for absolute beginners. The target group is design students, so I tried to be very careful in what to tell and especially what not to tell, but somehow it isn’t always possible to decide.
2022-10-29
DONE
- The grid in connected is now functional, more or less. Next up I should probably do copy & paste, and then do some quality of life things; like extending the settings dialog that I also added. Right now it only has one setting, for the grid size, and being able to change the save paths would be good too.
https://mstdn.io/web/@ratking/109253076471033762 - Last week I “hosted” a game jam for my students; the task was to create a small game depicting a single interaction, based on foreigners working in the German Democratic Republic. It’s interesting that a lot of teams chose not-game mechanics for this. In any case, as they pretty much all used PlayMaker, I will try to give them some scripting basics
2022-10-23
DONE
- I added a grid to the new version of connected, and it instantly looks a bit more professional. It is not really usable yet though, it just looks nice.
https://twitter.com/RatKingsLair/status/1583881853114933249 - While we currently have conceptual problems with Patou I still work on the basics, like adding “atmosphere changing zones” that can change the sunlight, fog and sky whenever the protagonist enters them. It’s somewhat similar to what the posteffect volumes do, but I dislike that they’re only reacting to the camera, so I will have to change those too.
In other news the spine animator I tried does really work for my case, so for now I just removed all spine related components; in the end it will probably not make any difference other than saving me some more time.
2022-10-20
SEEN
- Optional values in Unity - simple, but useful. (See link.) As I like to use [field: SerializeField] instead of just [SerializeField] for properties with public getters, I have to take care to write property.FindPropertyRelative("<PropertyName>k__BackingField") instead of just “PropertyName” inside of the custom property drawer.
https://www.youtube.com/watch?v=uZmWgQ7cLNI
https://gist.github.com/aarthificial/f2dbb58e4dbafd0a93713a380b9612af - Unity/URP: How to get a certain post effect from the stack and manipulate it:
FindObjectOfType<Volume>().profile.TryGet<XYZ>(out var xyz);
xyz.parameter.Override(value);
2022-10-19
PLAN
- I received the beta version of PandaBT 2, and somehow I’m inclined to give it a go. Apart from lack of time I don’t know really what kind of project I’d like to do with it. When I used the first version for Pry I somehow enjoyed it, but also got the feeling I’m making too complex behaviour trees. So I want to keep things simpler this time. Currently I’m thinking of very simple, but many, free roaming agents that serve the player in some kind of 8-bit dungeon, while mean heroes enter their domain and try to steal loot. Some kind of Dungeon Keeper (which concentrates on individual units instead of buildings like in a Tower Defence), but much less features of course.
2022-10-16
DONE
- I’m currently trying to add undo and redo actions to connected. My usual approach is very tricky this time because of the highly dynamic nature of the dialog nodes. I feel like I got the gist of it working, but there are so many edge cases … especially when anything is involved where the nodes have to be rebuilt.
- By the way, I’m still updating the list of “things I learned about C#”, date 2022-10-02. Maybe I should move this to somewhere else.
2022-10-13
DONE
- While it isn’t used in production yet I built a very very very simple spine animator for Patou. The actual plugin SpineAnimator always looks beautiful, as long as you don’t do anything crazy like walking backwards. So I just bend some bones and it might look okay enough, hopefully.
2022-10-10
SEEN
- Apparently it’s not possible in Unity to have a dropdown UI element without selecting options, which for my use case is a bummer. Simple workaround so far: create an empty entry in the options list and always select that one whenever something else was selected. Ugh.
2022-10-09
DONE
- Within the debug menu for our game project Patou it’s now possible to open a “build menu” - where other people, in this case our writer, can create their own NPCs (actually only ghosts) to test an NPC’s position and dialog.
2022-10-07
DONE
- Patou’s new debug menu has a new entry already: toggle the player’s gravity. This way reaching different places for testing is much easier now. I also added grouping to the debug menu, making it much nicer to use. A feature I’d also like to implement is being able to add shortcuts that consist of modifiers and a key.
2022-10-06
DONE
- I added a debug menu to Patou that is easily extensible inside its script. The core functionality is there already (although some extras would be cool), and now I can add two things that are currently missing: a mode to easily fly though the level with Kit, and a “build” mode that allows to create characters, for testing purposes.
2022-10-04
DONE
- Still working on the new FSM for Patou. I try to do the most complex part now, the “Distraction” state where the dog is lured by ruins and other things and should behave differently based on the distance to the ruin and to the player. For now I tried to make this a real matrix with three different states each (player can be near, far, away to the dog, and the same with the point of interest - for both). But this might lead to strange looking behaviour. For example it would probably be much better if the dog is always ahead of the player when approaching the ruin.
2022-10-02
SEEN
- I’m reading the book C# 10 Pocket Reference - and as I use C# only in the context of Unity and also only alone without looking at other peoples’ code, I encounter a lot of new things (and old things) I didn’t know. I should write them down here. Be aware that Unity 2021 only supports C# 9.
- I can write C# programs without any classes - the Main class will be automatically created in that case. Good for small and simple scripts. (Only one file with commands on the top-level is allowed.)
- To create a console program, I need to call dotnet new console -o MyProgram. To be able to give my program arguments, the Main method needs to have a string[] args parameter. It can also return an int.
- I can do logic operations like A && B || C bitwise too: A & B | C. The difference is that all parts will be evaluated, so it will only seldom make sense to use this.
- The type decimal is used in financial matters; it is based on 10 instead of 2. The suffix is M. It’s ten times slower than double.
- I can put underscores in large numbers: 1_000_000.
- Use the keyword checked to give an error if a number is overflowing.
- For lots of Booleans in an array, use System.Collections.BitArray.
- I can use verbatim strings which don’t support escape sequences, for example @”\\server\fileshare\hallo.cs”. In interpolated strings it’s possible to format values: $”15 in hex is {15:X2}”. I can use constants in constant interpolated strings
- It’s possible now to use ranges in array indexers. Indices and Ranges have their own types (Index and Range).
- I should probably use the modificator in more often, as it helps with the performance of big structs as parameters.
- I can use the short form new() for creating an object even outside of declarations, even as arguments when calling a method.
- switch not only has break, but also goto case x, goto default and continue (when inside a loop). I can do a switch case like this: case bool b when b == true.
- And since C# 8 switch can be used as an expression! I like this example:
string cardName = (cardNum, suite) switch {
(13, “spades”) => “King of spades”,
(13, “clubs”) => “King of clubs”, … // _ => … is the default - New in C# 10 - by typing namespace Namespace; at the top of a file all following types are defined in that namespace. Less indentation this way. And adding global to a using directive makes a namespace visible to all files in the project!
- I should remember more often I can “abbreviate” long namespaces via
using XYZ = Some.Very.Long.Namespace; - Deconstructors in C# 7 and later are somewhat strange to me, but could be neat in some places: var (width, height) = rect; (with a method called Deconstruct() defined).
- Instead of set one can also use init for properties - they’re only writable during initialisation then.
- I never use indexers, I wonder if I ever will. public T1 this[T2 index] { get …
- It’s possible to declare partial methods in partial classes. If they’re not extended they are private and must be void. If they’re not extended and not implemented, any calls to them get removed by the compiler(!) and behave like a method with the [Conditional] attribute (which I should use more too).
- In MyClass { public virtual MyClass XYZ() { … } }, it’s possible (since C# 9) to override XYZ() inside class MyDerivedClass : MyClass { … } so that it returns MyDerivedClass.
- Adding ref to a struct restricts its usage as it can only be created on the stack. This can lead to some optimizations. Adding readonly instead makes all fields inside the struct readonly, so it’s more clear what this structure should be used for; it’s also possible to add the readonly modifier to a function inside the struct instead..
- Apart from just internal, protected and private I can modify the visibility of a method or field with protected internal and private protected. Apparently, private protected means the member is accessible only within its assembly. So I can't create an object of the same type as the class I’m inside and access its members too - interesting.
- Explicit implementation of interfaces (via int MyInterface.Foo() { … }) can be used to hide members that may confuse the user.
- Since C# 8 it’s possible to have default implementations of interfaces. Those are always explicit though (i.e. the default implementation can only be called via the interface)! Interfaces can also now have static members, and default implementations can use them.
- Enums can be based on something other than an integer:
enum Side : byte { Left, Right, … } - Generic type parameters can be constrained with where T : <X>, and <X> can be (among others) class, class?, struct, unmanaged, new(), notnull.
- I use System.Action<> and System.Func<> a lot, but I should be more aware that with plain normal delegates I can also use ref/out and even pointers.
- C# 10 finally allows implicit typing for lambdas (so I can just write var hello = () => “Hello!”;).
- With C# 9 came the possibility to have static lambdas, so they don’t catch local variables.
Func<int, int> mul => static n => n * 2;
This also applies to local methods, adding static to them disallows them from using any local variables. - The iteration variable inside a foreach() loop is implicitly local, so it can be used inside a lambda without problems (which is the opposite of how the variables in the for() loop header behave).
- Anonymous methods exist - mostly replaced by lambdas, but they can be shorter by having to write the parameter declarations.
- Using using in front of the creation of a local Disposable variable automatically disposes it at the end of the block.
- Apparently it’s possible to iterate (use foreach()) over a class that has just a Current member and a bool MoveNext() method. To get the enumerator, create a class that has a GetEnumerator() method.
- Initialising a dictionary is possible via var Dict = new Dictionary<int, string>() { { 5, “five” }, { 10, “ten” } }. But also - and this is the way for anything with an indexer - like this: …string>() { [5] = “five”, [10] = “ten” }.
- I never used anonymous types. Apparently they’re not possible to use as members, as they need var and var is not allowed for member variables.
var anonym = new { str = “Test”, num = 100 };
They’re immutable and mostly used with LINQ. With C# 10 it’s possible to add with to create a copy with changed values. - Tuples can have names:
var tuple = (Name:”Brian”, Age:11);
static (string Name, int Age) GetPerson => (“Harry”, 34); - Records are like structs, but immutable, and can be very easily declared:
record Point (double X, double Y);
They automatically have a deconstructor and a Copy() method which allows the usage of with to create copies with different values. - The var pattern for pattern matching looks like a fun extra step.
bool ContainsAOrB(string str) => str.ToUpper() is var upper
&& (upper.Contains(“A”) || upper.Contains(“B”); - I can also use the operators <, >, <= and >= in patterns now. So something like
if (x is > 100) { … }
is useful in a switch. Also the keywords and, or and not can be used to combine patterns. - With LINQ I can project types into an anonymous type during a query:
var query = names.Select(n => new { Name = n, Len = n.Length });
foreach (var row in query)
Debug.Log($”{row.Name} has {row.Len} letters.”); - MinBy and MaxBy look interesting too:
names.MaxBy(n => n.Length); // returns longest name in list - Attention! A lot of query operators of LINQ get only executed when actually enumerating them (i.e. when MoveNext() of the Enumerator gets called). This is called deferred execution.
- With let it’s possible to add a new variable in a LINQ query (in query expressions only, not in lambda expressions). I pretty much never used query expressions, but I might as well.
- I never used dynamic for anything (because I love static typing actually), but who knows if I need it someday? It has some interesting characteristics, but in the end it’s just an object that you can shoot yourself with.
- I wonder if I should try more operator overloading, but on the other side I like to be a bit more explicit in my intentions and thus use method names instead. Yet it’s interesting that I can overload operators like !, |, %, ^ and even true and false.
- I also should look more into how to use Attributes (they inherit from System.Attribute and can be used for classes and members). Via GetCustomAttribute() the attribute is actually callable at runtime. With the attribute [AttributeUsage] I can tell an attribute which constructs are actually applicable. With C# 10 it’s possible to assign attributes to lambdas’ parameters and return values.
- Used for validation and assertion stuff, the attribute [CallerArgumentExpression] returns the actual written code. There are also attributes like [CallerMemberName], [CallerFilePath] and [CallerLineNumber].
- I should look into how my code could benefit from async/await.
var Result = await Expression
Instruction(s), getting called afterwards
Also usable with lambdas! For parallel execution I need to use Task.WhenAll:
await Task.WhenAll(DoSomething(), DoAnotherThing());
There’s also WhenAny. - One can even combine async and iterators:
async IAsyncEnumerable<int> CountAsync(int count, int delay) {
for (int i = 0; i < count; ++i) {
await Task.Delay(delay);
yield return i;
}
}
To consume it, foreach needs to be prefixed with await.
DONE
- I’m currently reworking the Follower character controller for Patou, as the old script became quite messy, and I wanted to give it better extensibility and readability too. My old system uses SUS (my own simple system based on utility theory) and Panda Behaviour Trees, and while it worked, it never felt like a good way to do it - I always dreaded a bit to get back to it to work on it. To be honest though I could still use SUS, as what I’m doing now is basically a recreation of the system, but tailor-made for the dog AI. In the end it’s now a finite state machine that has no fixed transition links, but bases everything on a priority value - just like SUS, but a bit more rigid.
- I can now hover the wires in connected and delete them with a right click context menu. This was a bit more involved only because the wires are done with a custom Unity UI element that doesn’t have a height or width.
2022-09-29
SEEN
- Once again downloaded the Godot "instancing" example project. It's still for Godot 3, and importing it in Godot 4 worked, but when running it, the line @export (PackedScene) var Ball threw an error. Apparently it now should be @export var Ball:PackedScene - which is actually a good change, the former syntax was so alien to me.
DONE
2022-09-27
SEEN
- I was a bit bummed today because I learned you have to call C# extension methods via this.Method() inside the extended class.
2022-09-26
SEEN
2022-09-23
SEEN
DONE
- A small problem in Patou turned out to be a bit bigger: OffMeshLinks. Those are special constructs for the pathfinding system which allow navigation agents to traverse gaps that would normally be, well, gaps. My problem specifically arises when the dog (the agent) tries to reach the protagonist and gets too near while being on an OffMeshLink. The normal behaviour per state machine is that he would just stop walking (i.e. following the path on the nav mesh) and get to the idle state. What happens is that on the OffMeshLink he follows the link to the end (as this is scripted that way) and then instantly follows it back again. There is no way to tell the navigation agent to clear the current Link, is what I learned today; and it’s also not possible apparently to find out if the agent is going to be on a Link during its path (maybe in some convoluted way). So instead I have to check all the time if the agent is on a Link and if the endpoint of the Link is near the player and if so, instantly stop following that Link. This works mostly, but probably only for this special case I constructed; further tests will most likely show the flaws. Oh boy.
2022-09-21
SEEN
PLAN
- As I created a graph of Patou’s behaviour I mostly made myself aware of what the dog actually should be able to do in the game. But transforming this graph into code proves to be harder than I thought; so right now I am still trying to plan the structure of the system on paper. My thinking currently is having “moods” that would be controlled by the dog’s current state. A “mood” basically is either “idle” or “following a target” or “focusing on a target”. It’s basically a usage of the navigation agent’s behaviour. Apart from the base state of the dog following the player, every state has exit conditions, especially if there is another state with a higher priority.
I thought about making the dog much more dynamic, letting him decide for himself how to interpret various parameters of signals by the objects around him (like reachability, danger, usability, distance, maybe even smell …), and that would make him an interesting AI companion maybe, but much less so a useful gameplay tool. And the latter is more important, because otherwise it would be frustrating for the player, never being able to tell why the dog doesn’t do what he was commanded to do. This might be fun if this were some kind of sandbox game, but Patou is much more of a straight forward story and exploration game.
2022-09-20
DONE
- Finally the save and load window came back to connected - and it’s almost complete already. I planned some kind of log within the screen, but I think I will remove it again, and add a general log window instead. This is for things like when writing or reading a file went bad, or just general infos like “file with X nodes loaded”.
2022-09-19
SEEN
- I tried local post-processing volumes in Unity (URP), and I’m less than impressed. The blend factor depending on distance is nice, but they can only be used with cameras (makes sense, but not always what is wanted in a 3rd person game) and the transition is hard when you just teleport inside the volume.
- Today I read an article from a month ago, titled “This game used TikTok to get 120m views, 60k Steam wishlists!". Videos and screenshots of the game look impressive enough, the quality is definitely high. The developers just launched a Kickstarter campaign back then so I checked out how it is/was going for them:
Three days left - and even with a meagre goal of 50K Euros they only got 38K so far (860 backers). The game will probably still get funded; but somehow this shows how damn useless TikTok as a marketing tool is. (And Steam wishlists too, at least for this case.) Update: The game got funded.
DONE
- Some more work had to be done on connected’s code regarding saving and loading; in the end I made it far more simpler than before, where I didn’t understand why I added the complexity in the first place. I also added a new command for the nodes, ced.TypeTextLocalised(), which allows saving its content to a special JSON file for the texts, instead directly into the normal dialog JSON data. (This was of course already done in the legacy Moritalk, but adding SmallBasic to the mix made it a tiny bit more complicated.)
2022-09-16
DONE
- I ported the old saving and loading code to the new version of connected, and it works so far, but I didn’t test it too deeply for now. Of course simply saving some JSON would have been a no-brainer, but the dynamic nature of the dialogs makes it much more complicated (for example, JUMP and PIN nodes have to be removed first, by rerouting their connections, for the saved dialog file that is to be used in games).
2022-09-14
SEEN
DONE
- I added an extendable top bar menu to connected; it’s not perfect yet but I might reuse it for Patou.
2022-09-13
SEEN
DONE
2022-09-12
DONE
- While I’m still thinking about how to tackle the main menu in connected (how dynamic it should be), I finally added (working) panning and zooming. Much more usable now.
- I created a visually appealing graph of Patou’s behaviour - it mostly shows which actions of the dog already work, but some things are still missing. The most important part though is that it is now relatively well formalised. And it makes me feel like I should start from scratch …
2022-09-09
SEEN
DONE
- Doing small stuff for the new version of connected, like adding little up/down buttons to the number fields, or making it possible to create nodes by dragging a wire from an IN connector. Hopefully this means I feel comfortable with the code again and can do the important additions like undo/redo, a main menu, save/load and so on.
2022-09-08
DONE
- I’m still updating the legacy version of connected from time to time, because the new version won’t be ready for the foreseeable future - I just don’t get around to work on it anymore. So now at least I added a config file that lets the user define where the different JSON files get saved, and the number of backup files.
2022-09-06
DONE
- Several small things done for Patou, nothing that noteworthy; there are now small texts that can appear over the head of the protagonist, and do appear when talking with an NPC. It does make the texts less “UI” and more grounded in the world. Portals can be better handled now thanks to Odin. Overall we’re mostly busy with planning and defining the dog’s behaviour more precisely, so the AI of the dog will probably be my main task in the coming weeks, again.
2022-09-01
SEEN
2022-08-30
SEEN
- C#/Unity tip: I dislike having only “Nothing” and “Everything” as names for these options of an enum flag, but I found out I can rename them by adding, for example, None = 0 as first element and All = ~0 as last element of the enum. (It must be the last one.)
https://twitter.com/RatKingsLair/status/1564588831562776576
DONE
- I wrote a blog post about my recent work on Patou’s NPCs. And today’s work mostly was making camera positions easier to handle for when creating a new NPC - of course this won’t reach the cinematic quality of most games nowadays, but I find it better anyway to have a more minimalistic approach. Mostly because of being able to finish the game with 2-3 people only …
http://ratking.de/patou/2022/08/30/talking/
2022-08-29
SEEN
DONE
- I’m more and more using Odin when I feel the need for it, and it really lets you make some neat tools inside Unity without having to create your own custom editor. So for Patou I wrote a script that would make parts of a character visible or not, to have a more diverse “cast” of ghosts. (This is an ancient technique of course, and I used it back then for my little goblins in Fascinated by Evil.) Such a script sounds pretty easy to do, but can be a bit tricky when it comes to usability for someone using it from the outside. Odin helped a lot to make more sense to the Inspector display.
https://fholio.de/assets/projects/fascinated-by-evil/02.jpg
https://odininspector.com/attributes/table-list-attribute - I finally fixed some bugs with the current connected dialog editor - the test mode wouldn’t work anymore, and it didn’t save changed texts inside the Text and Choice nodes. I really need to work on the new version of connected, especially as Patou will need a lot of specialised commands.
2022-08-26
DONE
2022-08-25
DONE
- I currently try to make Patou’s NPCs more reusable, so while the rudimentary Troll and Ghost characters still work as intended, it would be cool of course to have more options regarding their animations. So I tore a lot of components apart, and even added Small Basic once again. It’s still a rocky road though. But the more I work on it the more I feel confident with this.
2022-08-20
SEEN
2022-08-17
SEEN
DONE
2022-08-15
SEEN
2022-08-12
SEEN
2022-08-11
SEEN
2022-08-10
DONE
- For over a week now I worked on the aforementioned Snake clone. I try to generate a snake body on the fly in Heaps, which isn’t that easy if you’re used to all the maths functionalities in Unity, but somehow I managed to create something I like. The part of the snake digging down into the dirt is missing though, so after adding a head that will be my next task.
2022-08-06
SEEN
- Today I found out that the slerp() method for Heaps’ quaternions is broken in some cases. I wrote an issue for that, maybe someone will pick it up. I’m always amazed when I find such bugs.
https://github.com/HeapsIO/heaps/issues/1088
2022-08-04
SEEN
2022-07-30
SEEN
DONE
- We showcased Patou at the GameDev Leipzig Meetup two days ago, and it went well enough. We compared the old prototype with the semi-”realistic” graphics with the new style. As preparation for a playable demo I also did some small stuff like giving the troll NPC several animations or letting the dog rotate his head when walking.
https://ratking.de/patou/2022/07/29/gamedev-leipzig-meetup-in-july/
2022-07-25
DONE
- I added a sun to the sky shader in Patou, which was not hard to do - at least much easier than trying to make a big sphere rendering behind all the other objects but not being affected by the fog. The downside is that the fog post-effect we use blends over to the skybox, and so it can look like the sun is in front of objects far away. But well, this is a dreamworld, after all.
2022-07-24
PLAN
- I wrote down the concept for a little Snake-like dungeon game. The idea is that you actually control an earthworm who is capable of digging through dirt (in a limited manner). We’ll see if this will be fun. In any case it should be jam-sized more or less and doable in a relatively short amount of time, especially as this might be the second collaboration with voxel; although 666 Coins technically isn’t finished and not yet off the table of course.
DONE
- I finally found out what was causing the jittering when riding Patou. The problem was that I directly asked the transform’s position instead of doing that via the EasyCharacterMovement’s component. Always a new thing to consider, ugh.
2022-07-23
SEEN
DONE
- Because the dither shader (for vanishing Patou’s player model when the camera is near) has unexpected problems with the outline effect we’d like to keep, I changed it to some noise effect. It looks a bit like the kid is getting shredded, which is not the worst though, because this is all about memories and how they get lost and resurface sometimes.
2022-07-20
DONE
- I followed a tutorial for simple noise based “puffy” cloud layers, done with ASE. Just the thing I needed for Patou. We’ll see if it’s actually a viable shader, but it looks good enough for now. It’s for the void in between the floating islands, so there should be more optimizations possible.
https://nokdef.com/Articles/Stylized-Puffy-Clouds-Shader/
2022-07-19
SEEN
DONE
- I slightly updated our website, adding Patou, HAQR and bloed.
https://www.ratking.de/ - Also updated my portfolio - 666 Coins, Holocode, Alternative Artefacts, The Last Dream and HAQR - Der unsichtbare Raum were added. I’m on the fence if I should mention Behind Stars somewhere on it, because it was a lot of work, but then again it was never released.
https://www.fholio.de/
2022-07-16
PLAN
- As with the depressing news of Unity merging with a malware company and such, I want to get back to find another engine/framework/whatever for making small-ish games. Of course most things pale in comparison to Unity’s editor and ease-of-use and asset store and C# support and… Well, you get the idea. Anyway, I had fun before with Haxe and Heaps and other frameworks, so maybe it’s all about being a bit more persistent this time. It also doesn’t mean I will abandon Unity completely - too much knowledge would be lost, and too many cool tools at my fingertips would be not available anymore.
luxe engine - something I will try when it’s finally released. As with most similar engines/frameworks, having only a few people working on it is always a disadvantage. It being completely new and using wren as scripting language means there won’t be much outside support for a long time I’m guessing. I also don’t know its 3D capabilities.
https://luxeengine.com/
Flax Engine - a somewhat interesting amalgam of Unity and Unreal. It’s sad they took the centimetre units of Unreal, which made it instantly worse for me. But that’s a nitpick. Last time I tried it I liked it well enough and I will look further into it, especially as it supports C#. Not sure about its future though.
https://flaxengine.com/
Stride Game Engine and Focus Game Engine - the latter is a fork with various improvements of Stride. I list this here because it pops up frequently, and it’s 3D and uses C#. So it’s basically Unity, but not?
https://www.stride3d.net/
https://github.com/phr00t/FocusEngine
Defold - last time I tried it I was not really convinced by it. Mostly because it’s 2D focused, and the Lua scripting, even though I like Lua, made me somewhat miserable. Still, it might be time to look at it again, as it has support from big players now.
https://defold.com/
Heaps.io
Whenever I used Heaps I liked it more than I disliked it. Haxe is a cool language overall. I just don’t know I would use it for more complex 3D stuff, as I hit limitations with It Rains already pretty quickly.
https://heaps.io/
Kha
In the end it wasn’t much different than using Heaps when I did some ray-caster with it a while ago. But as this was like a 2D project, I would have to do more 3D tests first. Apparently it’s fairly cross-platform.
http://kha.tech/
Godot
Everytime I try Godot I’m super stumped by the node system. It seems I just can’t wrap my head around it, or rather my project. At least it supports C# more and more. Maybe with Godot 4 I will try it again, but I must say that waiting so long for a new version makes me a bit wary regarding the future.
https://godotengine.org/
Armory3D
I only did my simple cube puzzle game with it as a test, but everytime I look into it it feels unstable and a bit awkward how the components work together, due to it being imposed on Blender. Its biggest pluses are Haxe, and being cross-platform (theoretically).
https://armory3d.org/
raylib
Even though this is pure C and the 3D capabilities always look a bit sub-par, it might be just fun to do a small 3D puzzle game with it or something.
https://www.raylib.com/
DONE
2022-07-15
SEEN
- I read an article about how Unity and Unreal and so on are shit because they’re, basically, evil megacorps (probably true) and you should make your own engine. I’m all for that, somehow. I just don’t have the time (or rather: interest in it). Anyway, the article talks about using other frameworks instead, like LÖVE, which in the end isn’t that different in my opinion.
https://blood.church/posts/2022-07-14-making-your-own-engine-a-survey-of-the-landscape.html
2022-07-14
SEEN
- Today I learned that Unity’s NavMeshBuilder.UpdateNavMeshDataAsync() wants local bounds, and they need to be at least the size of world units as displayed in the NavMeshSurface (which is VoxelSize multiplied by TileSize). Nobody told me, so this took very long to debug / find out. Also this seems to be only one part of the truth (I guess the position is also quantized), but investigating this more is kind of a waste of time right now.
- Another coding tip: instead of using the distance to the next waypoint, just projecting the vector is more robust and probably more performant. (It might not fit all use cases though, I think.)
https://www.habrador.com/tutorials/math/2-passed-waypoint/
2022-07-12
SEEN
- Interesting Unity tip: while having several GameObjects selected, you can use R(min,max) and L(min,max) in the inspector fields for bulk changing their properties, either randomly or evenly distributed.
https://www.youtube.com/watch?v=pM8HSaIs1Gs
2022-07-11
SEEN
DONE
- I played around with Allegro 4.2 again, and dug out some old C code I wrote over 20 years ago. Ah, the good old times… Anyway, I have to use Allegro 4.2 and not the newest version because this is for a DOS project, and 4.2 is the last version to support DOS. The project itself is very simple, just displaying some paintings by my brother. So I didn’t bother too much with a well-crafted compilation pipeline. I just use the prepared Windows version of Allegro provided by Matthew Carr which compiles DOS executables directly. I test the executables manually in DOSBox. Works well enough for me.
https://www.mrdictionary.net/allegro/
https://www.allegro.cc/manual/4/
2022-07-08
SEEN
- Watched a short video about story writing. Glenn Gers recommends these essential six questions when writing a story: Who is it about? What did they want? Why can't they get it? What did they do about it? Why doesn't that work? How does it end?
https://www.youtube.com/watch?v=uL0atQFZzL8
2022-07-07
SEEN
DONE
- Apart from some simple stuff for Patou - having some portals to instantly teleport to different “islands”, generalising the digging sites for the dog, etc. - I worked a bit on shaders for the floor of the game. So the floor now uses a splat; . A bit hard to explain. In any case I also wrote a tool so I can paint the texture directly on the mesh, because somehow such a tool does not yet exist; which I find extremely strange. At least I could not find one.
2022-07-03
SEEN
DONE
- I changed how the player guides the dog in Patou quite a bit. Instead of directly selecting every “affordance” for the dog the player has to keep the LMB pressed and then it creates a line similar to the throw preview line. This way it’s more obvious how far your command reaches. Now the player pets or mounts the dog with the same key they would use to press buttons or activate other things, somehow this makes sense to me. I’m sure though that things will change again when we have more actions the player can do with the dog.
2022-07-01
SEEN
2022-06-28
SEEN
2022-06-27
SEEN
2022-06-25
DONE
- A small thing, but maybe very important for the gameplay. I added a quick air friction factor to the player in Patou, just so jumping forward isn’t that powerful. This will be relevant for the puzzle situations, but it might make some people mad. We’ll see.
2022-06-23
SEEN
2022-06-22
SEEN
DONE
- I work on and off on the moss shader for Patou, and it has its merits, but overall there are some hard problems like the bending of the normals, and I don’t really know how to solve that. Hopefully I’ll find a way.
https://mstdn.io/web/@ratking/108525364851843127
2022-06-20
DONE
- I tried to create some kind of moss shader for Patou, which places some moss colour only on the top of the object. Though it goes in the right direction, it’s of course a problem that a lot of models don’t have the correct normals for such a shader - they should be smooth everywhere, which would look bad of course with the lighting. So I try to put smoothed normals into UV3, but that only works apparently if I duplicate the mesh. In any case I will probably have to spherize the normals just so it looks even more “natural”.
And we did the very first test of the game on the Switch, i.e. I got the Rewired plugin for correct input. It ran slowly, but somehow faster than I expected. But optimizations will have to take place, a lot.
2022-06-18
SEEN
- Today I read that alpha testing is ill-advised on the Switch, and performance is better if you use alpha blending. Ugh. I’ll have to test this soon-ish …
2022-06-17
DONE
- I tried to create a more robust system for Patou’s “puzzle” elements. So instead of a trigger directly manipulating a moving platform (for example), the designer (mostly me) adds behaviour scripts that listen to these triggers and then do the manipulation. This way intertwined scripts are easier to do, e.g, you might have to press a floor platform and a button to move a platform.
2022-06-14
SEEN
DONE
- Finally, a happy ending for my Tab shortcut problem with bloed. “Mad” on the Unity Discord showed me the solution: a keyboard Event in the editor has *two* KeyDowns - the second one with KeyCode.None. I have to call Use() for that one as well.
Well, after a bit of testing the happy ending actually isn’t happening. There is no KeyCode.None event for Tab in Unity 2021. It works in 2019 (and 2020 probably) though. So, who knows what’s happening here. My hacky solution of emulating a right mouse button click is still valid I guess. - I wanted to fix the sideways moving platform in Patou because it will probably get used in some puzzles and maybe in other instances as well. Kit would move her feet even when standing still on the platform. The first step was giving her a “reference transform”, so the animation would be based on what Kit currently stands on (if needed). And after only more than a day of work (ugh) I fixed the tiny jitters by replacing transform.position with Rigidbody.position (of the character)
2022-06-13
DONE
2022-06-12
DONE
- I have several shortcuts in bloed which I handle by using Event.current inside a method registered to the SceneView.beforeSceneGui callback. One of the shortcuts is the Tab key, to change the rotation of the currently selected bloxel. This works for nearly all the shortcuts; for the Tab key too, as long as I use bloed in Unity lower than 2021. With 2021, the Tab KeyDown event selects the first item in the Scene toolbar (e.g. the Scene search). Which means the next Tab press cycles to the next element and so on. Other shortcuts don't work either as long as something in the toolbar is selected. By the way, pressing Tab actually behaves similarly in Unity 2019/20, but instantly deselects the search toolbar afterwards. So for Unity 2021 I try to mimic this behaviour - when the user presses Tab, I create an Event that fakes a right mouse button click, inside a callback registered to EditorApplication.delayCall. This works - almost. Annoyingly, it has a strange glitch: the bloed cursor moves a few pixels upwards during that fake event. At first it was not clear why - I use the same mouse position from the Tab key press event! After a bit of searching I stumbled upon a forum post describing a similar problem. The very same toolbar is once more to blame. Somehow the mouse position I give the event is not the mouse position that I get. Or something. Anyhow, the proposed solution is scary - getting the toolbar's height, adding it to the position before I feed it to the event. Apparently - as I was told by Mad on the official Unity Discord - there is a better way to completely catch the keyboard events. I do hope they will someday allow me to see this wondrous solution.
https://twitter.com/RatKingsLair/status/1535930053388804096
https://forum.unity.com/threads/mouse-position-in-scene-view.250399/
2022-06-08
DONE
- Kit is now able to throw a box precisely onto a platform (if she’s near enough), as the throw trajectory “snaps” a bit to the centre of the platform. To make sure the box does not leave the box, I remove the forces when it touches the correct platform. Now I have to think about what to do with this - Patou will try to get to the box, catch it, and bring it back to Kit. This is of course not wanted - so I’m thinking about adding little throwable stones for the player that are only there for guiding the dog, and the box is for different things.
2022-06-07
SEEN
DONE
- For Patou I experimented a bit with a shader I call the Whiteness - we want to reproduce the feel of being in a sketch or art work by adding a white blobby outline to the whole screen. It’s harder than I expected, but even in the very ugly version it adds a bit of novelty. I don’t think this one will be finished anytime soon though.
2022-06-01
DONE
- I submitted HOLOCODE. It’s missing a lot of things, especially sound, some story and testing, but at least it has some content and the idea in itself is what I wanted to try out.
This also concludes the 12th Kajam that I hosted. I’m pretty disappointed by the low turnout, and I will definitely not host a Kajam again. The audience is just too small, and the Kajam is thus a niche within a niche.
https://alakajam.com/12th-kajam/1302/holocode/
2022-05-31
SEEN
DONE
- A lot of additions to 256 bits - probably named HOLOCODE from now on - and the deadline for it is today. It’s by far not finished or in the state I think it should be, but I want to submit at least *something* to my own jam.
2022-05-25
SEEN
- I noticed that Visual Studio 2022 would close all tabs whenever I create a new script in Unity - apparently I’m not the only one affected, and thankfully a fix is on the way. Ugh, always such annoyances.
DONE
- I worked a bit on how the camera rig systems in Patou, it looks much nicer now when there’s a switch between dialog and walking - and throwing. A dedicated cam rig for throwing is the first step towards a better throw mechanic in general, to make this less of a hassle in combination with puzzles. It is planned to not directly command the dog to platforms and stuff anymore, but guide him by throwing things. This of course means that the throwing should be much less error-prone, which is why I’m reworking it.
- The memory blocks in 256 bits can now have wrapped selection rectangles.
2022-05-23
SEEN
DONE
- I finally defined a “puzzle” in 256 bits and it opens a door on success. There is so much stuff to do, and it might be too boring for a game, but I think I will be able to submit something at least. Tomorrow I’ll try to layout an “outer world”, but before I actually get to building it I first want to add help screens and a “physical” start button to the holo-world. By the way, in the end my implementation of negative numbers was flawed, so this was fixed as well now.
2022-05-21
DONE
2022-05-19
SEEN
DONE
- Because I somehow felt up to it I made the “ruin trigger” pressure plate activating based on weight (well, kind of) in Patou. I added a function that would find all rigidbodies on top of a collider, so that was the missing thing. Because just checking for forces applied to the pressure plate doesn’t work reliably (as physical bodies can “go to sleep” and then wouldn’t do forces anymore), and just checking everything inside a trigger lets through far too many false positives.
- In 256 bits it’s now possible to manipulate the single nodes - e.g. change the calculation method of the CALC node. The most important part though is the BLOCK node that contains information about which portion of a Bitfield to use. Bitfields basically are data storage, represented by a various amount of bits, and could theoretically be changed outside of the virtual computers. I am still thinking about how to do the ASGN (or COPY) node, because if it uses a DATA OUT connector, then I also need BLOCKs to have an IN connector. I wanted to reserve that for changing the X/Y values.
2022-05-18
DONE
- So I finally decided against using A*PPPro for Patou, at least for now, because I found a way to update the nav mesh without any frame loss. For example, there’s a hidden parameter, named preserveTilesOutsideBounds, which is very useful for updating only a part of the mesh without removing the rest. It’s a shame that the API of the navigation stuff is mostly guesswork, because the underlying tech is powerful enough for our game.
https://forum.unity.com/threads/update-navmesh-at-runtime.475237/
2022-05-16
SEEN
- I watched a YouTube tutorial about dynamically baking navigation meshes in Unity. It feels like this is always connected with a loss in frames, even though it’s done asynchronously. It makes me consider using A* Pathfinding Project Pro again for Patou, but I think I will use a lot of prebaked nav meshes instead, especially as we probably won’t use the Unity terrain anymore. I just don’t want to change the whole nav agent stuff for the dog.
https://www.youtube.com/watch?v=RuoK7w1OIT0
DONE
- A few days ago I created a shader for Patou that would gracefully hide an object that is near the camera (using dither, because transparency always is ripe with problems) - which is of course for the player model, so the player can’t look inside of Kit (always a bit creepy when eyes and teeth float in the air). I now tried the same for the dog - which uses another shader, from the fur asset, so I had to expand that one with an ASE function. Unfortunately the fur seems to ignore the position of the object and is always at 0/0/0, which means I have to take the fragments’ world position, and this just doesn’t look good. I guess I will make another specialised version of the shader function and feed it the world position directly.
2022-05-14
DONE
- I added a big portion of the programming functionality to my Kajam 12 entry (working title is 256 bits). The user can place nodes and connect them via wires. Everything is a bit wonky, but it mostly works - now I have to think of the actual nodes, and what kind of tasks are to be done within the game.
https://mstdn.io/web/@ratking/108302063101553181
2022-05-12
DONE
- Still a bit sick, but I worked on my Kajam 12 entry. My plan is to create a programming game where you have to jump inside the “computers” to solve the puzzles. Right now I have a room with nicely glowing edges everywhere triangles don’t share a normal - this will be the “VR room” look maybe. In any case I’m quite inspired by System Shock and System Shock 2 and maybe a bit by Wreck-It Ralph. The glowing edges are a side effect only - I actually need them to check collisions for some wires.
2022-05-09
SEEN
- Pressed the two analog sticks by accident and suddenly a debug menu popped up in Unity. Why the hell didn’t I know about this?
2022-05-08
PLAN
- The Kajam ends this month, and I’d really like to make an entry too. For now I’m planning to make a simple fantasy console / esoteric node-based programming language. The part that interests me right now is the visualisation of the “internal memory”, as a simple bitmap square.
DONE
- As planned, yesterday we showcased Patou at the Lange Nacht der Computerspiele. It was somewhat strange to get back to in-person events with sometimes dozens of people in the same room, but most of the time it was a good experience. People loved riding the dog, and overall the game prototype worked smoothly. There were some actual game stopping bugs though, one where the dialog of the troll would stop working, and one where the player character gets stuck forever.
2022-05-04
DONE
- After we streamed a bit of Dungeon Keeper, one of my favourite games, I noticed that I never uploaded one of my better jam games, DANGEON!, anywhere. So now here it is, in all its glory. Still proud of it.
https://ratking.itch.io/dangeon - I’m finally *somewhat* content with how the character controllers function in Patou. There are still some issues with the spine animator plugin that I’d like to see fixed (the back feet are often dangling in the air), so I contacted the developer about this. Maybe it will improve in the near future. Overall we’re now preparing the prototype, as outdated as it is, to showcase it at the next small exhibition this weekend, at the Die Lange Nacht der Computerspiele (Long Night of Computer Games) in Leipzig.
- Totally forgot to mention that TRI: Of Friendship and Madness, our non-smash hit from 2014, finally also has Simplified Chinese localisation - thanks to EchoriverTranslators, who did it for free basically. Crazy stuff.
http://tri-game.com
https://twitter.com/ertranslators
2022-05-02
SEEN
2022-04-29
DONE
- A lot of work went into actually simplifying the character controllers of Patou. I looked at Horse Animset Pro, and while it is far more complete than my own solutions, and of course works much better in most aspects, again I decided not to use it. Mostly because it seems to force things on me that I didn’t like. In any case the Walker character is now mostly where I’d like it, but the Rider controller needs more love.
I also finally wrote a janky little tool to combine and unify all the grass detail prefabs of all the terrain chunks - this is only needed for the prototype because we won’t use terrains anymore later on.
2022-04-25
SEEN
DONE
2022-04-20
DONE
- Nothing substantial, but I submitted HAQR - Der unsichtbare Raum to the Google PlayStore. It went mostly painless, I just had to find my signature keys’ password again. I am sure there will be complaints though, so I don’t expect the app to be ready for Die Lange Nacht der Computerspiele (where we will showcase it, in a way). There’s still the itch.io download of course.
2022-04-19
DONE
2022-04-15
SEEN
DONE
- I finally submitted bloed to the Unity Asset Store and got an email that it might take up to 33 business days to get back to me. Ugh. At least this is out of my brain now and I can finally do meaningful stuff. Oh, and I changed two small things, so there’s also version 1.1.1 up on itch.io.
https://ratking.itch.io/bloed/devlog/369961/bloed-v111 - Once again I changed the base character controller for Patou. I am not happy about that, but I think Easy Character Controller 2 is, after Character Movement Fundamentals and after that my own controller, so far the most robust solution. Of course there are still things I find annoying, but it feels like I can work around them. In any case this is all taking much too long, but will hopefully be a net plus in the end.
2022-04-13
SEEN
2022-04-10
DONE
- I updated bloed to version 1.1, with the new Cuboider tool being a great improvement if I may say so. I should finally make a quick introduction video for bloed and be done with it. Overall there is far less interest than I hoped.
https://ratking.itch.io/bloed/devlog/368009/bloed-v11 - The ORGANIZE node for connected is coming along and a user could change its text and font size already. The main functionality, using it as a group, will be in focus as soon as I get to implement selecting and deselecting nodes.
2022-04-08
DONE
- So for my own test case in Patou I set the Physics’ fixed delta time from 0.02 to 0.015, and this makes the problematic jitter pretty much disappear. I hate this solution, it feels like a random hack, but for now this makes everything smoother anyway - even the dog riding strangeness is looking much better now. But of course this will have to be revisited at some point in the future.
2022-04-07
DONE
- I’m still working on and off on the character controller for Patou, and instead of actually getting results I’m still pulling my hair about jittery movement. I really don’t know where this comes from, the other CC works quite well without doing much differently. Ugh.
- I added some visualisation of connected JUMP nodes, and it works well enough. I also made a more dynamic (and correctly functioning) resizing capability for the TEXT and CHOICE nodes. This will also be the basis for the upcoming ORGANIZE node (in the old version this was called the COMMENT node).
- For bloed I want to make a better Cuboider tool - so I changed the current Cuboider to be the standard Bloxer tool and copied stuff from the Copy&Paster to the now new Cuboider. I already can create very big cuboid rooms/blocks this way, but a lot of more polish is needed.
2022-04-05
SEEN
2022-04-03
DONE
- The JUMP node is back for connected, and I had to make the IN connectors more dynamic for that. Theoretically I now could add more than one IN connector, but for this tool it’s not needed. Maybe I can think of something, though. It’s always nice to have options.
- Currently I’m also working on new character controllers for Patou, because even if an asset is good overall, it will never satisfy all my needs and will always be awkward to use. And while my controllers were never perfect either, at least I have (more or less) full control over them. So, as usual, I imported my old character controller for Pry and 666 Coins and changed it a bit so it would be usable for a game with third person perspective. Somehow I had to put a lot of work into making sure it doesn’t jitter all the time, and I don’t really know why it actually jittered - it seems the camera should follow the character in FixedUpdate(), but that feels wrong too. So now I have a lot of smoothing in several places and it mostly works.
Apart from that I thought a lot about how to do the “horse controller”, as that’s what the dog kind of is in the game. For now I created an extremely simplified version of the normal character controller and let it follow the main controller, like an appendix. This way I have a character that consists of two capsules, defining some length, and so I plan to put the 3D model of the dog into the middle of the two. I am eager to see if this works, but I am sure it won’t look great out of the box. And there’s also the question how to do the whole ordeal for the dog when it’s just a follower, i.e. a nav mesh agent. I think I will just do the same for that and accept 95% of the strange edge cases that this will produce.
2022-04-01
DONE
- Did some small stuff for 666 Coins - changed the fog from linear to radial, added an introductory text to the tournament, and the flying enemy is saveable now. The latter needed some rework, especially as the enemy’s path referenced the path nodes - which can, on load, not exist. Instead it uses the raw positions now, and while there might be problems with blocked nodes, those should be very seldom.
2022-03-31
DONE
- I fixed some issues in bloed, but I should wait for G.P. or someone else to check it for new bugs I might have added. In any case I really should do a short video, showcasing what bloed can do, and submit it to the Asset Store. I don’t expect any sales though.
- Made a short video of the SWITCH node of connected. It has a white text colour now, and mostover it’s 95% functional - only thing missing is the individual mirroring of the out connectors.
https://twitter.com/RatKingsLair/status/1509428866422616064
2022-03-30
DONE
- (connected) An annoying visual glitch with layout groups not updating instantly, leading to out connectors being at the wrong position for one frame at least, could be solved by this thread. I just had to make sure I am actually calling LayoutRebuilder.ForceRebuildLayoutImmediate() for the correct parent, and in LateUpdate().
https://forum.unity.com/threads/force-immediate-layout-update.372630/
2022-03-29
SEEN
- Never heard of the [Delay] attribute before, might be useful at some point, when there’s more stuff to calculate in OnValidate(). But it really should be the standard behaviour anyway… What a coincidence, it’s something I had to think about yesterday when I made the SWITCH node for connected.
https://twitter.com/BinaryImpactG/status/1506229641933213696
2022-03-28
SEEN
DONE
- The SWITCH node for connected is quite a challenge, because it needs a lot of special things. For example, the “random” switch has several labels that indicate which probability each case has (based on the value entered by the user). Those labels have to be updated anytime that value was changed. This isn’t super easy with SmallBasic, so once again I had to put scripts inside strings. As usual, it's a bit awkward, but it works quite okay, and as an alternative it’s always possible somehow to create a subroutine.
2022-03-27
DONE
- Last week I created and finished the Hand of Fate, the new enemy for 666 Coins - a floating hand that would punch the player when it notices them. When it roams through the dungeon or chases the player it also takes closed doors into account, which is nice. I could improve my pathfinding algorithm quite a bit, so in the end I gave the new enemy type the “approved” stamp and was eager to see it in the Tournament Edition of the game.
Except this was just a wet dream - voxel tested the enemy over the night (or rather his day) and noticed such severe performance flaws with the pathfinding algorithm that I did the best/worst thing possible and removed the enemy before uploading the game to itch/Alakajam.
Then, over the weekend, while having no access to Unity, I tried to improve the pathfinding blind, with no compiler. Before that I actually did some deep profiling and noticed that using my Position3 structs would create some (memory) garbage, and iterating over the whole list of open nodes every time to find the one with the lowest F is also a bad idea. So the first, simple yet very effective step was adding an integer index to each node and using that instead of the position when putting them into the hash maps. Then I wanted to get rid of iterating over the nodes by inserting the nodes into a linked list at the right position from the start. Turns out LinkedList<> also generates a ton of garbage because it actually creates a LinkedListNode<> for each entry. In the end I replaced it with my own simple linked list implementation, using the pathfinding nodes directly. The final result is that I don’t even have to use coroutines (which I planned to do) for creating the paths - generating them is super quick now. But what a weekend that was.
https://alakajam.com/post/1642/666-coins-tournament-edition
2022-03-22
SEEN
2022-03-21
SEEN
DONE
- There were some really jarring visual glitches since I switched Patou from BIRP to URP - mainly bright white spots flashing whenever the dog was in the view. After some checking and testing I could determine that the error was happening due to the Fluffy fur shader somehow producing negative colours sometimes, which produced bad results with the bloom effect of URP. So I added a Max node to the shader of Fluffy (via ASE), and told the developer.
- I streamed 666 Coins a bit, mainly the development of a flying enemy type. I didn’t get very far, but at least there’s a box that finds a path between two random points and flies along that path. It looks very awkward, as this is inside a grid, but I guess it’s better than nothing. It ignores doors, which should not be that hard to implement, and I still don’t know what attack pattern the enemy should perform whenever they see the player and are near enough to them. I also need to improve the pathfinding algorithm as it does some very stupid things.
2022-03-19
DONE
- The last 3 days I mostly worked on a new HAQR adventure, Der unsichtbare Raum, as there will be some kind of exhibition at our office building. We show High Five Romance Race and maybe Mondar’s Dungeon, not because they’re our best projects, but they are pretty easy to showcase and Patou isn’t ready yet for a long time. In any case, Der unsichtbare Raum is using the old HAQR code base but extended, and the story is a more fun adventure overall if I may say so. Again it was just fun to write the logic in SmallBasic.
https://ratking.itch.io/haqr-unsichtbar
2022-03-15
DONE
- I took the first steps to convert Patou’s Unity project from the Built-In Render Pipeline (BIRP) to the Universal Render Pipeline (URP), the latter being stable now, allegedly. So far there are some strange things happening to the terrain, and the process made me notice that the Nature Renderer plugin we use doesn’t actually support Unity 2021, and the version that supports needs a subscription. Blergh. I want to reduce Patou’s complexity anyway, this might be the incentive to get rid of some of those “nice to have” features that only bloat the thing. Overall we still need to think about if and how we want to plan for Switch support, because the terrains are going to cost us.
- Version 1.0 of bloed is up on itch.io. I took some liberties with the version number I guess, but I didn’t want it to be a 0.x when I actually put it on the asset store. (Still need a video for that.)
https://ratking.itch.io/bloed/devlog/358183/bloed-v10
2022-03-14
DONE
- Several small things were done for 666 Coins’ Tournament version, mostly to distract me from the biggest TODO: flying enemies. But well, now the walker enemies teleport the player back to a place they came from instead of just a random position. (This was done via breadcrumbs.) The floating mask enemy only shoots when it sees the player. Tables give the player a special crouch height so they can hide beneath them. Rats walk up and down steps much nicer now. The Tournament does not save the game state anymore.
2022-03-13
DONE
- I added a “prize detector” (actually it detects the Jamician statue) to 666 Coins. While the most important part is missing (respawning of the prize), this means it’s kind of ready for being part of the Alakajam Tournament. There is a lot of other stuff missing though.
- Progress on connected is very slow, but steady. It’s now possible for a node to have more than one out connector - dynamically. It will become “fun” as soon as undo/redo is involved I’m sure, especially with more than one node. Next steps: being able to delete nodes and connections, and adding more node types, especially condition and “set variable”.
2022-03-12
DONE
- And more bloed stuff. A frantic bug hunt, mostly consisting of writing a method that would search and fix inconsistencies in the bloxel chunks. In the end it was a != that should have been a ==. Of course. To be more specific, the problem was that chunks would get deleted when they didn’t have a meshes - which should only happen when they also don’t have any bloxel data anymore.
2022-03-10
DONE
- I worked a bit on the internals and bloed can now be used with the URP, and probably HDRP too. The main difference is that for the markers and the cursor I don’t use materials in the Resources folder anymore but generate them on the fly. So now they’re in all render pipelines visible. I’m mostly waiting for a bug report by G.P. before uploading a new update. Their problem sounds horrible to me. I remember having missing bloxels/faces before, and I truly hoped I fixed it. If I remember correctly, there was inconsistent information with shared bloxels at the border of chunks.
https://itch.io/t/1980162/issue-with-missing-bloxels
2022-03-09
SEEN
- A note to myself when I have problems with Rewired: check if the Map Categories are actually assigned to the Player. That is all.
DONE
- As the resizable nodes in the new connected interface are a bit of a hassle I decided to concentrate on new multi-line text input fields that can’t be resized (for now) and instead use a modal input field where you enter the text and then type enter to apply the changes.
- We’re part of our office building’s showcase, and we will prepare Highfive Romance Race again. But also a new game story based on HaQR, and here I hope we can do it in time - and somewhat tastefully. I wrote down a small story with a safe and ghosts.
2022-03-07
SEEN
2022-03-06
DONE
- Team COOLFRIENDS had a meeting and we concluded that while we still want to work on the 666 Coins and make it a proper game, our next goal should be adding some stuff and submit it to the Alakajam Tournament. There we could garner some feedback maybe, and some players. Shortly before the meeting I also finished creating the rat enemies I was working on by just modifying their behaviour a bit - they now have a cooldown when they hurt the player, and after a few seconds they would attack again. They’re just so cute!
- I sent a bug report to Unity because of the annoyances I had with TMPro text input fields. This whole ordeal (who knows when those bugs get fixed) made me rethink how I want to have text input in connected. I should change it so that longer texts will open their own window when being edited, just so I don’t have the hassle with resizable nodes anymore.
- I did some refactoring for connected, the old IMGUI version mostly, and now it uses short identifiers (three letters, e.g. “cho” for choice nodes or “swi” for switch nodes) instead of indices. All this for later use, when I make the whole system more configurable. It’s a bit messy, but in the end nobody will care, apart from me.
- Did some first careful tests with bloed and URP. It mostly works, although I had to change the bloxel material manually (not a big deal though). There are lots of errors though when doing automatic lightmapping, as the tool doesn’t create secondary UV coordinates every time a bloxel was added or removed. The most annoying problem for now is that all the gizmos are not shown though, probably because they try to create a material for the BIRP instead for the URP.
Also I learned that the automatic unwrapper creates overlapping UVs for my meshes, so I changed the packMargin value to 0.1f - not sure if this is a good value, but it fixes the problem.
https://docs.unity3d.com/2019.3/Documentation/ScriptReference/UnwrapParam.html
2022-03-02
SEEN
DONE
- As Patou should be localisable too, I put a tiny bit of work into the localisation stuff from my game jam base code and moved it to its own repository; it’s now called “simple localisation helpers” (slh).
https://github.com/ratkingsminion/slh
2022-03-01
SEEN
- I talked in the IndieArena Discord a bit about Switch and Unity with Oswald and others, and it seems we will have to look for another solution when it comes to the environment in the game. Apparently Unity’s terrain system is a killer for the Switch.
DONE
2022-02-26
DONE
- Did a “day without glowing rectangles” yesterday, was great.
- Working more on the UGUI version of connected I can now connect nodes (or rather their respective connectors) again - a small but important step. Now I want to find out if it’s feasible to use Small Basic as a configuration method for the various node types, it would make extending the functionality a breeze.
- I think I fixed (or rather: circumvented) the problem with the T-junctions in bloed that would lead to broken geometry with clipped bloxels affected by noise. I tried to identify these cases and just remove them from the noise. Because fixing T-junctions is an extremely hard problem, so this was the saner solution.
https://ratking.itch.io/bloed/devlog/351908/bloed-v08
2022-02-24
DONE
- Today is some kind of deadline for Patou’s prototype, and apart from some jittering still existing it looks good. At least I don’t think the animations are the culprit any more. The worst thing though is that everything will have to be replaced for the final game, from art to code. Work went into more sounds, new nav meshes, some monolog for finding the dog, a ghost scene of memories … Well, it will make sense later.
In any case I somehow have a really hard time memorising that a higher value of the DefaultExecutionOrder means that it’s executed later, not earlier.
2022-02-22
DONE
- Lots of small stuff is now done for Patou and more to come, as the deadline for the prototype looms. I think I solved the laggy movement mostly, but when riding there are still problems - but in this case maybe the animation is actually to blame. Sounds were added, a sun, a dialog for the bridge troll, a start screen, and so on.
2022-02-21
SEEN
DONE
- (Patou) For the bridge troll’s trash heap of toys I wanted to bake some 3D toys into a simple cone-shaped mesh in Blender, or rather its texture. After a lot of experiments it succeeded. The main problem was that Blender doesn’t use the GPU for baking in a lot of cases, and so the process was painfully slow most of the time.
2022-02-20
DONE
- The look of Patou’s prototype level is somewhat done now, at least in my department. It looks pretty, probably because we mostly used assets from elsewhere. Still, building a bigger environment takes a lot of time, it’s good being aware of this for the future. What’s missing for the submission on Thursday? Let’s see - sounds in any case. Particles (mostly wind), and some sun. A big pile of trash, for the troll. Some kind of dialogue between Kit and the troll. Paul’s music. Adjusting colours of the sky, the light, the post-effects, the fog. An “end scene” for when you complete the ruin’s puzzle. It would also be great if finding the puzzle would be a bit more involved than pressing just a key; and also if I could solve at least some of the animation glitches.
2022-02-19
DONE
- (connected) I found out how to use the meshes with UGUI, so I could draw a bezier curve with it already.
- Patou’s prototype level is coming along. I placed a lot of trees and rocks, only missing is all the rest. I definitely have to write down all the things that need to be remade once we can start the real production - which is “everything”. I plan to have some kind of “director” that would control Patou and the protagonist whenever needed, especially in cut-scenes, and als rework the character controllers.
2022-02-17
SEEN
DONE
- While working on Patou I found out today that changing a skybox, or rather its colours, does not update the ambient lighting in the scene in Unity. One has to call DynamicGI.UpdateEnvironment() whenever the skybox is changed. Which is a very expensive method. To mitigate this, maybe caching the values from RenderSettings.ambientProbe could help.
https://docs.unity3d.com/ScriptReference/RenderSettings-ambientProbe.html - The UGUI version of connected needs, of course, some splines to connect the nodes to each other. Unfortunately there is no out-of-the-box solution, apparently, for such curves in UGUI. I guess I have to write my own stuff (again). I will base it on this simple polygon tool - apparently UGUI has their own kind of meshes to render them.
https://github.com/CiaccoDavide/Unity-UI-Polygon
2022-02-15
DONE
- I did some more tests with UGUI and resizable and draggable nodes for connected, and it works better than expected. I will probably go this road further.
- For Patou I created a more or less “real” puzzle situation in a memory ruin. It’s not yet finished, and the size is not good (much too small), but it’s a good start that makes me kind of hopeful.
2022-02-14
DONE
- After experimenting with UGUI a bit to check out if it actually is usable for connected’s nodes system. It is, I think. I will have to create some nodes before I can say for sure though, as there are already quite a few annoyances, related to TextMesh Pro’s text input fields mostly. The main difference to the IMGUI version will probably be that nodes won’t resize automatically while typing text, but that might even be a good thing. Or maybe I can somehow do it optionally.
- While working on Patou I noticed today that Unity’s navigation mesh surfaces don’t automatically stitch together when being used with terrains. Quite a bummer, and there doesn’t seem to be a real solution for it. So I will probably change to A* Pathfinding Project Pro as soon as possible next month - even though we don’t really need this, as Patou is not a procedurally generated game or anything. But limitations like this make me anxious somehow.
https://forum.unity.com/threads/connecting-chunks-of-navmesh.527039/
2022-02-13
PLAN
- I felt defeated today, because while connected is now kind of ready to be released, it really isn’t. There are just too many little annoyances and bugs and glitches that don’t make it a good candidate to be out in the open. So my thinking is to either abandon the project completely, or try to reuse as much as I can while changing the basic node stuff, or rebuild it completely in another framework. For now I want to go with option 2, because rebuilding it will definitely take too much time. (Besides, I never found a good framework that I want to work with.) Option 1 is, well, utter defeat and not really an option, especially as I think the idea of dynamic dialogs with choices as their own nodes is still good and something I don’t see often. I just don’t know when I have enough time to dedicate.
DONE
- I tried to add some little rats to 666 Coins. It’s really fun to see them running around, not attacking the player - until he or she steals the crown. Then they get quite dangerous. There’s still a bit to do before they’re really usable as enemies.
2022-02-09
SEEN
DONE
- (connected) More and more code was removed, so I’m finally at a point where only the needed stuff is left. Which means I can tackle the first obstacle for a real release: remaking the test dialog. Right now it doesn’t even support mouse input, and it’s needlessly sophisticated for being a good demonstration dialog screen. So I will probably just write something from scratch.
- The player can now move special blocks back and forth in Patou - although that isn’t really the end goal. What we really want is the dog being able to use these, so the logic for that has to follow soon enough.
- We upgraded Patou to the latest Unity 2021 version, and it feels a bit strange. Hopefully this feeling won’t last too long.
2022-02-07
DONE
- Today I tried to manually move a nav mesh agent - Patou - along with a moving platform, still with Unity’s Nav Mesh Components. The end result works somehow, but it has a lot of limitations (which is okay) and feels extremely messy (which is less okay). Right now this is only for platforms moving up and down, so we’ll see how this works with platforms moving sideways. I will try that next.
2022-02-06
DONE
- (connected) I named the interface I was talking about IBlackboard, to make it clear that it can actually be used for anything the user wants. I could also remove a lot of unnecessary code, although there’s still a lot of left.
- I got around adding a better movement for when Kit is riding Patou. It’s far from perfect, but it’s a start, which was the most important part. But it showed me that I need a better way to organise the movement types and other things, because it gets quite messy.
2022-02-03
DONE
- Moritalk, renamed to connected (at least for now), finally uses JSON instead of Lua to save and load dialogs. I also put it on github, in order to be able to change back stupid changes, because those will happen now that I try to eliminate the rest of Behind Stars from the project. The big question is how to replace the Lua functionality from all the dialog nodes like SetVar and so on - I’m thinking of an IConnectBrain that users have (or can) implement and that would have a lot of methods like void OnVarSetString(string variable, string value) - I guess I’ll see if it’s too much early enough.
- I added the “new” Navigation Mesh Components by Unity to Patou, and it was a hassle again. Apparently it’s still not possible to add their own package to it, although it might be that Unity 2020 is the problem - I will have to upgrade to 2021 anyway because of a fur tool we want to use. In any case, the dog in the game can now be commanded to walk to a pressure platform and activate it that way, which is nice but still wonky of course. And with the upgraded navigation components early experiments make the way for movable platforms that will transport Kit and Patou around.
2022-02-01
DONE
- Fixed some visual bugs in Patou after I noticed that I used the [DefaultExecutionOrder()] attribute wrong - higher numbers mean this script gets executed *after* the others. Oops.
- It’s a slow process, but as my next task for Moritalk I want to switch the saving and loading of dialogs from Lua to JSON. To not break everything at once, I want to support both until I don’t have to anymore.
- I uploaded my simple state-machine code (ssm) to github, and the same with the simple utility-theory based “AI” system (sus). Honestly, I don’t know if they’re actually good, but working with those made it quicker for me to create more complex systems.
https://github.com/ratkingsminion/ssm
https://github.com/ratkingsminion/sus
2022-01-31
SEEN
DONE
- Together with Teresa from Würfelpech e.V. we created a QR-code-based espionage thriller where the player uses their phone to search through a room. Basically it’s an escape room, but with less props. HaQR is our entry for the Global Game Jam 2022. Again I used SmallBasic for the scripting side, as functionally the game is just another CYOA.
https://ratking.itch.io/haqr - We finally have the girl and the dog imported into Patou. It looks quite wrong for now - there are errors in the mesh mesh, cloth, animation, etc. - but still, this is a very important step.
2022-01-25
DONE
2022-01-24
SEEN
DONE
- Working on Patou a bit more, and we semi-decided on a puzzle mechanic, which is not the craziest ever done, but at least it’s doable and could result in a few fun level situations. Also it’s very reusable but still allows experimentation. Furthermore we decided which part we want to make for the prototype, and my current task is to look if I can salvage Behind Star’s dialog editor - but so far I mostly stumbled over a bug that I just don’t know how to fix …
2022-01-23
DONE
- (bloed) Today I learned that, in a MonoBehaviour with the ExecuteInEditMode attribute, its OnDestroy() method gets called when just changing the currently edited prefab. Annoyingly, OnDestroy() is the place where I clean up any leftover BloxelLevel meshes. The solution now is to also check if the “Delete” or the “SoftDelete” command was called. No idea why it’s SoftDelete, but well.
- More bug fixes for bloed, all of them somehow related to prefabs. There were problems unpacking nested BloxelLevel prefabs, and problems deleting and duplicating BloxelLevels inside prefabs. Those problems should be fixed mostly now, but I am sure I missed something.
2022-01-19
SEEN
DONE
- While the riding functionality in Patou isn’t really done, the switch from normal player controller and nav mesh agent to a singular rider/mount controller kind of works now. The same with the player leaving their “horse”. It’s a start, at least.
2022-01-17
DONE
- I got a bug report for bloed, claiming that their computer gets warm with bloed active, even in an empty scene. I indeed tested that and noticed that the CPU usage gets pretty high. Seems like calling SceneView.RepaintAll() every frame is not a good idea. For now I just commented this out, but of course this means there are now problems with rendering/updating some of the editor markers. I will have to look more into this.
2022-01-16
DONE
- I updated 666 Coins a bit, now enemies (for now: the walker enemy) hear objects the player throws. The walker just looks into the direction of the objects, but that can already be advantageous. This needs testing though, because it might have some bad effects that I didn’t think of. In any case I also fixed a few bugs while working on this.
2022-01-15
SEEN
2022-01-12
DONE
- I had to re-think my approach on how to implement riding in Patou. I thought just switching the models around would suffice, but that was very naive of course. Thus I added an additional controller named Rider, and this is what then will use the combination of the kid model and the dog model. In the end I will probably have to create separate models (with animations) too, but for now I’m going to try it like this.
2022-01-11
SEEN
2022-01-10
DONE
- Just so I can remove a picture from my hard drive - the formulas to create discrete noise are:
f1(x) → noise(1.55 * x + 0.212) * 2 // change values as needed
f2(x) → lerp(f1(floor(x)), f1(ceil(x)), frac(x))
There is also cellnoise now, which probably makes my formulas redundant.
https://graphtoy.com/
2022-01-08
SEEN
2022-01-07
SEEN
PLAN
- We might participate in this year’s Global Game Jam, and I’m a bit excited - this time I want to do a mix of digital and analog game design. I’m mostly inspired by a Lord of the Rings board game which has a companion app that gives out randomly generated side quests. Maybe there are even more interesting things that could be done with this.
2022-01-06
PLAN
- I need (or rather: want) to have another look at LibTessDotNet, as there have been some updates since I last did that. Currently I use an older version in bloed, and while it is good at creating polygons out of outlines, some of the generated triangles are invalid (i.e. have an area of zero). So I have to combine it with poly2tri, and my current hope is that I can ditch the latter when updating LibTessDotNet. ClipperLib will stay, as it is needed for the Boolean operation of creating the actual difference between two bloxel sides.
It would be interesting if I could/should make the whole bloxel chunk generation more dynamic and robust by calling ClipperLib and LibTessDotNet on the fly. It definitely would create a lot of garbage and make performance a lot worse, is my guess.
https://github.com/speps/LibTessDotNet
https://github.com/greenm01/poly2tri
https://github.com/Voxel8/ClipperLibCs
2021-12-28
DONE
- The last few days I added saving game states to 666 Coins, just to see if it works. There are some problems left, but overall this is very useful when the levels get larger. I actually added quicksave and -loading, but I don’t really want to have that, because this is still a roguelite with permadeath. So instead the saving will only be done when the player quits the level, so they can continue later. And maybe there will be a secondary game save for when they snatch the Unholy Crown.
2021-12-25
DONE
- For Pry I took the revamped settings system (for options like field of view, mouse sensitivity, etc.) from 666 Coins and improved it even further. I had to change it because the system was intertwined too much with the UI and localisation was initialised after the settings - leading to errors with the different sliders’ and toggles’ labels. Now the settings are based on ScriptableObjects, and scripts can subscribe to any changes, making it all much more dynamic.
2021-12-24
DONE
- I did some small improvements for 666 Coins, like adding a slider to change the head tilt (when moving sideways), as some people got motion sickness apparently, or adding a context on-screen help hint when hovering some interactable. I think I only want to change one or two small things before we evaluate a commercial version of the game.
2021-12-21
SEEN
2021-12-20
DONE
- bloed is now version 0.7.3 - the biggest change is that joists also can now be created inside a prefab. I encountered several problems with prefabs, so quite some work went into things nobody will probably notice.
https://ratking.itch.io/bloed/devlog/326799/bloed-v073 - With a small change I optimized 666 Coins a bit further: Unity’s sound system is really primitive overall, so I had to write a small manager for the looped sounds which would play even if the listener (aka the player) is far away. I noticed that mostly when I dropped some items and their “thud” sound wouldn’t play because of their low priority - too many audio clips playing at the same time does that. Of course there is a reason this happened; Unity doesn’t check if the looped sounds are actually audible because they could be, if their spatial settings are set to lower than 1, or if their rolloffMode is set to logarithmic. Strange enough I remember doing such things for TRI already, one would think Unity does at least some small optimizations where it’s possible.
2021-12-18
DONE
- I worked a bit on bloed, as I mostly wanted to solve a problem that appeared when one would place two opposing slopes next to each other, and those slopes would have a Noise setting higher than 0. Turns out I cannot solve this, at least not with how the bloxels currently work. (The reason is that I don’t create vertices where they would be needed for such cases.) Oh well, very disappointing. At least I could fix the Joister’s snapping functionality and also add some color settings. There are several small things on my list though before I upload another version.
2021-12-16
DONE
- Once again I streamed a bit of the development of 666 Coins. This time I made the Unholy Crown, the thing you need to steal, an item instead of loot, so it takes some space in the inventory. Also, very important for atmosphere and immersion, being inside of water makes the correct sounds now. Last but not least I replaced all the calls of Unity’s own Random class with an instance of System.Random, so we can have seeds - very useful testing and performance optimization.
2021-12-15
DONE
- For Patou I am currently trying to think of a better approach regarding the player’s input and actions. Instead of just checking things with Boolean variables, I now added states that would define which actions are currently possible and how the different keys will be interpreted. We’ll see if that’s sensible. Next up is trying to be able to ride the dog.
2021-12-14
DONE
- We noticed that 666 Coins has horrible performance on weaker GPUs - and indeed, it has 10K draw calls on average. Not very good for such a small game. I tried two solutions for dynamic occlusion culling, but the first isn’t working, and the second isn’t really satisfying. Instead we had a lot of success with just reducing the far clip plane (as we have some fog in the game anyway, it was a no-brainer), and I noticed the lanterns’ spot lights produced a ton of draw calls, probably because of having shadows. Even if they’re outside the far clip plane. So there’s a lot of optimization potential.
2021-12-12
DONE
- I submitted 666 Coins to the 7dfps jam on itch.io - even though I don’t think it’s finished. But it is playable, and I had a very nice and intense playthrough. Today I mostly did a bit of polishing, added an apple as a health provider, and made the start menu more useful. Hopefully, we will extend this a bit. But even if not, I’m proud of the achievement and did some cool things that I can incorporate in Pry probably.
https://itch.io/jam/7dfps-2021/rate/1315178
2021-12-11
DONE
- For the 7dfps project, now semi-finally named 666 Coins, I added a compass - and enemies can hear the player now. They definitely got more dangerous instantly. I had to rewrite nearly all the AI logic for that, but in my opinion it was worth it, especially as I can now extend it easily. For example, it would be cool to have a tool that can distract enemies or even lure them away. I don’t think we can submit a real version of 666 Coins to the 7dfps, but still, it’s playable and is a good base for a “real game”.
2021-12-10
SEEN
DONE
- Today I won a battle against Blender, in some sense. For quite some time I had big problems getting my animations (not based on Rigify, but custom bones with constraints to some Empty objects) to play in Unity. After finding out I have to bake all my animations in the Pose mode, and also be very careful what settings to set in the FBX exporter, it still didn’t work. Well, at least I thought so - only after a few hours I noticed that the animation would work in the Scene view, but not in the model’s animation preview. Damn. In any case, the 7dfps project has an animated character now, and I can finally do other things.
https://answers.unity.com/questions/213414/how-do-you-bake-constraints-into-a-blender-armatur
2021-12-09
SEEN
DONE
- Good news: Patou got funding approval by the MDM. Well, at least for 60% of the sum we wanted. Better than nothing, though.
- The 7dfps project’s moving enemy is working now, mostly. They walk aimlessly around and attack the player on sight - by running towards them and teleporting them to some random location! Of course there are still some edge cases to cover (for example, the player can be teleported onto the ceiling of the “dungeon”...). I want to create a 3D model for it next, and of course add sounds. Then it should be mostly finished.
- I fixed an oversight in Terrobot X’s code editor - comments and strings would not honor any tabulator key input. I wish I could invest a bit more time into the project, especially as wixette updated the ISB plugin in the way I wanted, and it should be usable for me now as a sandbox programming environment. Maybe I should do a very basic next-steps plan for it.
https://github.com/wixette/isb/issues/28#issuecomment-986408636
2021-12-07
SEEN
DONE
- Unity’s navigation system is quite sub-optimal, but there actually is an improved version on Github. Why this is still there only, after five years, and the Unity editor itself comes with the lame bake-only solution, is beyond me. In any case I even tried the preview version called “NavMesh Building Components”, and after quite some hassle I got it installed. Just - it doesn’t install everything. Important components just aren’t there, and I suspected different assemblies, but it seems that wasn’t it. Instead I reverted back to the Github version, even though it’s not updated anymore and stuck for a year now; it might be a problem that I still use Unity 2020.3, but who knows - you don’t get actual information about this. Ugh, Unity. In any case, I can now create nav meshes during runtime of the 7dfps project, and even update them so open and closed doors get recognized. So, on to some moving AI agents.
https://docs.unity3d.com/Packages/com.unity.ai.navigation@1.0/manual/index.html
https://github.com/Unity-Technologies/NavMeshComponents
https://forum.unity.com/threads/navigation-ai-experimental-cant-find-navmeshsurface.1168856/ - I was finally annoyed enough by the fact that pressing F in Pry and the 7dfps project during play-testing it in the editor would zoom in and out constantly, and searched in the forums if someone solved this before. Indeed, I wasn’t the only one. I took the best solution (Windows-only, though), and extended it so it would only deactivate all the shortcuts of Unity when the Game window is focused.
https://forum.unity.com/threads/unwanted-editor-hotkeys-in-game-mode.182073/page-2#post-7717177
2021-12-06
SEEN
- UPBGE is a game engine for Blender. Might be worth a look, even though it uses Python - unfortunately the documentation isn’t finished, and I’m really not a fan of that.
https://upbge.org/ - I watched a video about the level design of It Takes Two, and it was pretty interesting. While I’m on the fence if I like the game or not, I can’t say it isn’t well made.
https://www.youtube.com/watch?v=QbMF1nCiIkQ
DONE
- During a productive meeting with voxel we assessed the current state of the 7dfps project (still no real title) and also defined the features we want to do for the next milestone. We now reached the MVP as I added quite a few sounds for the player, the enemy and the loot items. I used oceanaudio mostly for this, and it is nice, but absolutely underpowered - having several tracks and being able to combine them is such an essential feature for me. So I checked some other audio software and in the end came back to Audacity, as most other software has a price tag and/or is not really suitable. But as Audacity is still a bit sketchy, I will use the fork Tenacity instead. There are no releases yet, but the nightly build works fine so far.
https://www.ocenaudio.com/
https://tenacityaudio.org/
2021-12-04
DONE
2021-12-03
DONE
- Uploaded v0.7.2 of bloed - the tools window was stealing keyboard input, hopefully this release fixes this problem.
https://ratking.itch.io/bloed/devlog/320944/bloed-v072 - I reactivated the Health component in the 7dfps project, and now the player can die! Even from falling!
2021-12-02
DONE
- For today’s game dev stream I extended the 7dfps project by adding doors and collectible loot, after I created a simple security cam enemy yesterday. An interesting problem arose when I made the doors unclosable as soon as something was in the way - be it the player or an item. I used a trigger for that. But when the player collects the item that is in the way, it wouldn’t “exit” the trigger, the event doesn’t fire. Apparently, Rigidbody.detectCollisions is the solution to that (which of course only works when there is a Rigidbody). Setting it to false actually also calls the OnTriggerExit() method - something which Destroy() and Collision.enabled = false; surprisingly don’t.
https://www.twitch.tv/ratkingslair
https://forum.unity.com/threads/fix-ontriggerexit-will-now-be-called-for-disabled-gameobjects-colliders.657205/ - Another “interesting” problem was creating new terrain tiles, which I currently evaluate for Patou, mostly because I don’t want to have a gigantic terrain right from the start, so I want several smaller terrains. And then this: Unity is stupid when it comes to test their own things, thus terrains don’t allow digging holes when one uses them out of the box; instead I had to move them 100 units down, and use “Set Height” to set the height to 100 of the first terrain (so it’s back at 0 level). Which works - but extending the terrain now with new neighbour tiles only creates them with 100 unit steep slopes. To get around this, I copied Unity’s terrain tool code (namely the FillHeightmapUsingNeighbors() method) and changed it a bit so it would recreate the heightmap based on the absolute origin. Which is pretty dangerous, because there is no undo, and it changes the assets directly… always remember to use your version control!
https://github.com/Unity-Technologies/UnityCsReference/blob/2020.3/Modules/TerrainEditor/PaintTools/CreateTerrainTool.cs - I tested bloed on Unity 2021.2.4f1 today - and it almost works out of the box. Apparently there is a problem though with the GUI inside the scene getting key input when it shouldn’t. I will look into this soon enough.
2021-11-30
DONE
- For the 7dfps project I’m currently evaluating AI solutions, and I think I will just try to use SUS as much as possible. It feels powerful enough to create some interesting behaviour, but still not too complicated. In the last few days I also added things like being able to collect items (a bouncy test box for now), and the light gem for the player.
- I streamed a bit of Terrobot X’s development. Right now it’s becoming some kind of “fantasy console”, so there was enough stuff to show for the stream; I mostly just added input and line drawing functions, so I could emulate a simple platformer and a simple Pong thing.
- Some fog was added to Patou - namely “Volumetric Fog and Mist” by Kronnect, mostly because it supports “fog of war” out of the box. After having a lot of problems with it in my own scene I wrote in their support forum - and yes, the problems were on their side. Thankfully a fix came not much later.
- Bloed had a very interesting bug - playing the game in the editor would attach all the meshes to the currently opened prefab. Of course it was a bug in my level code - but it’s a bit strange how Unity wouldn’t spit out errors when in-game code would change a prefab. Yes, there is a warning *beforehand*, but only in a very vague way.
- Two days ago I also gave Pry a little update: she does auto-crouch when a ceiling too low if in front of her. It feels pretty smooth!
2021-11-27
DONE
- As voxel uses bloed quite a lot more than I ever did apparently, he finds enough bugs for another update. I set the version number to 0.7.1 because in the end it’s an extension of the previous release, which was all about bug fixes too. This release fixes transparency issues, and a lot of problems when new textures are added to the project.
https://ratking.itch.io/bloed/devlog/318755/bloed-v071
2021-11-25
DONE
- I uploaded some bug fixes for bloed, which means it’s now v0.7 - removing and recreating prefabs’ meshes works now, and UV sets get serialized correctly. Oh, and there was some issue with rotating textures, which sometimes was just ignored by the TEXER.
https://ratking.itch.io/bloed/devlog/318010/bloed-v07
2021-11-24
DONE
- For Terrobot X’s code editor I wanted to have more control over when Unity’s UI system is actually allowed to take over the keyboard (to switch between controls and activate them), so I had to set the selected game object manually. Stuff like that. While I didn’t need the link below, it might become useful later on.
https://www.gamedeveloper.com/design/stupid-unity-ui-navigation-tricks
2021-11-23
SEEN
DONE
- Apparently there are more bugs in bloed than I thought. While I fixed some glaring issues with the Helpers methods in combination with prefabs, I noticed that the TEXER still has problems with setting different UV sets, or rather with saving them. I might fix that bug this year even...
2021-11-22
DONE
- I’m pretty happy that I could finish my Adventure Kajam entry, The Last Dream. (Zauberwald is the name of the “engine” for it.) In the end the story is much shorter than I wanted, but that’s a good thing because it actually is enough already for a challenging game. Of course tester feedback is needed, as I am sure some things are not obvious at all, and so it will be a bit of a frustrating experience. In any case, the game does what I wanted it to do - motivate me to create this tool (for further use later on), and a story.
https://alakajam.com/adventure-kajam/1212/the-last-dream/
https://ratrogue.itch.io/last-dream
2021-11-21
SEEN
2021-11-20
DONE
- I extracted Pry’s character controller for the 7dfps project. It’s missing quite a few things now, even though I had to copy a lot of files. The main difference though is that instead of Rewired the extracted version uses Unity’s new input system. It’s mostly working okay and is flexible, but it annoys me how cumbersome it is to implement a simple “hold”/”pressed” behaviour for some input.
2021-11-19
PLAN
- voxel and I plan to participate in the 7dfps, and already wrote down a concept for a randomized stealth game. Let’s see if it works out this time! (I would love to see something like Eldritch more focused on stealth.)
https://itch.io/jam/7dfps-2021
DONE
- First steps were done towards Patou reacting to other things (sensing them etc) in the world. For now he just stands still at an object that is marked “danger”; later on this could be used like this for example: There is a murder of crows guarding a place, and the child won’t be able to get past them. Only thanks to Patou’s constant barking in the direction of the crows they will fly away. When he stops barking, they come back. So for a while, the child might have to do things alone.
- I uploaded version 80 of Pry, just to have a feeling of progress. I am not sure what to do next for it, the AI most likely needs an overhaul, and I could use SUS for that, but that would be some major rework probably. In any case, one could make a real prototype now with the things that are already implemented.
2021-11-17
SEEN
DONE
- Improving, but not really progressing, some projects: Patou’s Simple Utility System (SUS) got better debug display (considerations now can have identifiers), Pry now leans her body with a SphereCast check so she can’t look through the wall anymore when climbing a ladder, and Zauberwald has a better, desaturated colour scheme now, and a visual hint for when you can drag a window.
2021-11-16
SEEN
DONE
- So for Patou I could combine SUS with PandaBT now as I wished, and also added some simple debug display. It’s not super convenient because one has to find out which consideration is which, but other than that it should help with development.
- I worked a bit on Pry’s leaning, so the player can also lean forward (by pressing both Q and E at the same time). It’s cool, but has a major bug - when climbing a ladder it allows you to look through walls. Disabling leaning while climbing ladders would be the easiest solution, but that’s a bit lame. So I will try to think of an alternative.
2021-11-15
SEEN
DONE
- I created an extremely simple system of utility theory “AI”, for Patou and reusable for other projects. I call it SUS. Combining it with PandaBT is possible, but this is very awkward, as there is no way to change a tree during runtime without overhead. So either I write my own behaviour tree system too, or choose another plugin. There are several free solutions, but PandaBT is just so nice to use and debug. And it seems the developer is back from the dead and plans to update it.
https://github.com/luis-l/BonsaiBehaviourTree
https://github.com/Yecats/UnityBehaviorTreeVisualizer
2021-11-14
PLAN
- I don’t think I will submit anything (playable) to the Adventure Kajam. While I’m happy with the state of the Zauberwald “engine”, and while I’m not that bad with coming up with a potential story, actually writing down this story, and creating puzzles, takes quite a while. Too long for the time that is left, and I am not motivated enough, unfortunately.
DONE
- I replaced some Time.unscaledDeltaTime with Time.smoothDeltaTime in my code of Pry, and it definitely helped with a smoother camera. Let’s hope it doesn’t break anything, as this is not working with a time scale of zero anymore.
2021-11-12
PLAN
- Again, after so many times, I’m back to thinking about how to do the AI for our games. This is for both Patou and Pry, and while the two game concepts are vastly different in their requirements - Patou has only one single character who doesn’t try to fight you, while Pry will feature several NPCs in pursuit of the player - I think there are a lot of intersections in functionality. Maybe it means I just have to modularize some parts. In any case, right now I want to get back to utility theory - at least for the decision making process of a game agent. Because this is the part that annoys me the most with the current AI of Pry’s enemies, even though they mostly behave how they should. Still, my solution of mixing some state machine into their behaviour trees was never a good solution.
DONE
- Terrobot X, although now a side side side project, got a small update - the code editor (still the only piece actually existing of the “game”) now has automatic scrolling when the user moves the caret. It had its pitfalls, thanks to the dynamic nature of the content of the scroll rect, but for now it works. The second thing today was line numbers. I can finally think about the actual game, maybe.
2021-11-11
PLAN
- Right now, each room in Zauberwald has its own scripting engine. This way each engine can have subroutines with the same name, called RoomEnterFirstTime, CombineThings, etc. I might change this though, because room-based actions can potentially overwrite general actions (e.g., combining an object with another one could have a different effect in room X than in other rooms), and with the current solution I get annoying boilerplate code. For example, I have to set a Boolean value called “CallGeneralAction” to false every time something in the specialized subroutine happens.
2021-11-10
DONE
- Patou now catches a ball thrown by the player. Well, it’s not really Patou, but a red-tinted clone of the player character. Anyway, sooner or later I will have to think of a good, extendable system for Patou’s AI states.
2021-11-09
DONE
- While I still might choose A* Pathfinding Project Pro (God, that name) later on, right now I think Unity’s own navigation mesh system is fine for what we want in Patou. We don’t even have enemies in the game, just one single character following the player. The off-mesh links just work out of the box, more or less, and the fact it’s all part of Unity makes it easy to use, in contrast to A*PPP.
- In Zauberwald, the Rooms’ windows can now be dragged around freely. (That reads a bit strange, without context.) It sounds simple, but as soon as you have the different configurations for anchor, pivot, scale, etc. of a UI element to consider, it becomes a nightmare if you want to prevent windows from getting dragged out of view. In any case, using RectTransform.GetWorldCorners() for retrieving the actual size and position of the windows was the solution, at least in this case.
And I went a bit further and added support for pictures. They have to be in the Resources folder, and get added by name, for now. The tricky part was making them resize to the layout correctly. In combination with the stretching RectTransforms, it’s very complicated. Instead I just set “Preserve aspect” to true and make the Images extremely wide or high. Hacky, but works for now.
https://docs.unity3d.com/ScriptReference/RectTransform.GetWorldCorners.html
2021-11-07
DONE
- I planned to support more than one window per room in Zauberwald, but after a while of tinkering it didn’t really seem to be a worthwhile feature. So I ditched and vastly simplified some logic. There’s also a configurable limit of items on the floor for each room now. Overall the project is on a good way, the biggest hurdle right now is getting images to work - and the story as my actual entry for the Kajam. My current idea involves social media, inspiration, and cyberspace.
2021-11-05
DONE
- A lot of things happened for Zauberwald, and one could now make a little story with it. It features a functional inventory (more or less), switching between rooms and interaction with things - examining, using, combining. Some work went into polish, like fading text out and in as soon as it changes via script. Rooms each have their own Small Basic interpreter instance. I really should think of a short story idea now.
2021-11-04
DONE
- After tweaking it for some time I think I will stick with the “Fundamentals” character controller for Patou (or rather: the child) for now. I also imported PandaBT again, because after researching other AI solutions for the dog behaviour I think most of it would be too bloated for a single NPC “just” following a player. Plus I really like PandaBT’s scripting language approach instead of the node trees that often can get too big, and a mess.
Though I still think I will keep an eye on SGOAP, for Pry’s enemies. But I will probably never be content with how the enemy AI works in this game anyway …
https://assetstore.unity.com/packages/tools/ai/sgoap-ai-solution-167167
2021-11-01
SEEN
DONE
2021-10-30
SEEN
2021-10-29
SEEN
DONE
- Zauberwald now has multiple pages - and dragging of individual words. Looks interesting so far, hopefully it translates to a somewhat good game.
2021-10-28
PLAN
- For Zauberwald I had the idea to let the user move the text by letters instead of scrolling. It looks far worse than I thought, so I got rid of the algorithm. I still don’t like the idea of scrolling though. My next plan is to support multiple pages instead; very crude, but effective.
DONE
- For some time I noticed that some enemies don’t hear anything in Pry - seems like a bug introduced after version 71. Turns out it was a simple, but hard to see copy & paste error; I once read in an analysis that those happen extremely often, so yeah, I can confirm that.
- I improved the support for the tabulator key in Terrobot X’s code editor. Lines can be indented and so on. At this pace though I don’t think this will ever become a full game. Nonetheless, I always wanted a more robust code editor for my code-based games...
2021-10-26
SEEN
DONE
- I dug out Zauberwald, the text adventure I wanted to create with my brothers, for the current Alakajam Kajam (theme is “adventure”). Basically I did a reevaluation of how I want the text interaction to work, and for now I’m confident the approach I used in CitApp and now Terrobot X is probably the sanest way. (Which means using “text chips” for each word, instead of a whole text block.) More or less. There was a bit of parsing to be done, but now I can slowly create actual gameplay, maybe.
- The options in Pry are mostly working now. Who thought that Colorful, an ancient Unity plugin for some post effects, is still working, and the best way to change brightness and contrast directly? Of course this is all rudimentary, so other options will be added later on. If ever.
- Undo and redo were added to Terrobot X’s code editor. Another case where I reused code, this time from bloed. The implementation in Terrobot was still tricky, because my approach of changing the text dynamically made me think around two corners, and even change some stuff. For example, for deleting a character via backspace or the delete key I now select the character and then delete the selection. This was necessary because there were a lot of edge cases with line breaks.
2021-10-25
SEEN
2021-10-24
DONE
- I copied a lot of code and UI from Behind Stars and Under Hills over to Pry, because I wanted to add a start menu. I also copied the debugging menu (for quick noclip stuff and so on - not a console) and the settings menu, although none of the options (brightness, etc.) are working yet. But at least Behind Stars wasn’t a total loss this way.
2021-10-22
SEEN
2021-10-21
SEEN
2021-10-20
DONE
- I did a bit of work on Terrobot X’s code editor - who’d known adding support for the tabulator key as an afterthought would be a bad idea?
2021-10-19
SEEN
DONE
- I tried to fix a small bug in Pry: Enemies that got knocked out would sometimes die just by falling over. The problem was their low pain tolerance (which is there for them being killed by attacks instantly when they’re not in “search player” mode), so just hitting the floor or even colliding with their own bones would instantly kill them. It’s actually a hard problem to solve, as there are so many contradicting rules - in the end it’s a lot of tweaking of different values, instead of one hard solution.
2021-10-18
SEEN
DONE
- I did some small things for Pry. It always annoyed me how jerky the movement is when climbing through a 1.5m high window (because it’s smaller than the player, but they still fit through). With my current solution of automatically letting the player crouch when they climb through the window it should be smoother now. The same with hiding under tables - it won’t work against the physics engine anymore. (Mostly.)
2021-10-14
SEEN
2021-10-11
SEEN
PLAN
- Things I’d like to see in Terrobot X’s code editor soon-ish: better support for the tabulator key, copy & paste, (smooth?) scrollbars or at least pages, maybe even support for several carets. Overall I will have to rework the lexer for text coloring based on the syntax though. Sooner or later.
DONE
- Finally back on vacation, and already working on a lot of stuff: Terrobot X’s code editor now has text selection (of course this is a minor feature, but important nonetheless), and we do more and more planning for Patou (especially the story).
2021-10-05
SEEN
2021-10-02
SEEN
- Finally watched noclip’s documentary about Prey - the Arkane Prey from 2017, that is. It’s actually a good game, especially because it is a lot of game. But I must say that I also understand why it didn’t sell that well. Especially when it comes to the “uniqueness of the story”. Maybe it’s just lacking zeitgeist.
https://www.youtube.com/watch?v=kXLxaKrcFZ0
2021-10-01
SEEN
DONE
- I worked on Terrobot X’s code editor a bit. I have no idea how sensible parsing actually works, but on the other hand it’s not the most important thing to get the syntax coloring right. I just hope for a smoother experience than working with Unity’s inbuilt text input boxes. Some things I do to make it easier for myself: a) only allow mono-spaced fonts; b) don’t have text-wrapping, instead do overflow for lines (and let scrollbars handle the rest); c) concentrate on Small Basic as the language to be used with this editor, so don’t get too fancy with the parsing.
2021-09-30
SEEN
DONE
- I changed a small thing in Terrobot’s web version - instead of using the F keys F1 to F5, users should use Alt+1 to Alt+5 instead in order to quick-execute their little programs. I totally forgot that F1, F3 and F5 already have standard functionality in web browsers and thus are unusable with a WebGL game …
- Afterwards I started with the extended version of Terrobot, calling it Terrobot X for now. First - and probably final task, when I give up - will be a functional code editor based on UGUI. Which is not much fun to make, but necessary. Only if I really finish this thing, the actual game will be planned more thoroughly.
2021-09-29
PLAN
- I will think about extending or rather making a full game out of Terrobot. The main problem is the “IDE” inside the game - Unity’s input text boxes are just not up for the task. So I would have to write something completely different, maybe something with text element blocks like in CitApp. In any case I just like the idea of controlling robots remotely on some alien planet's surface. It has a lot of potential. The question is if I want to go into the direction of some kind of exploration/adventure game, or a Zachtronic-like with discrete tasks to do. I’m leaning to the former, with maybe the latter as little missions in-between. (Current project description: “The Witness, but with remote controlled robots.”)
DONE
- I uploaded version 70 (getting rid of those x.y.z version numbers) of Pry, with (hopefully) improved ladder climbing, locks and contextual key prompts. The ladders were the main work today, with adding the possibility to leave the ladder without using any buttons (you have to stand on the floor for that), and adding some colliders that make sense, especially when it comes to the top part of the ladder.
2021-09-28
SEEN
- There will be a “Frankenjam” - a game jam happening in Franconia, starting November 5th. While I could travel to Nuremberg for this, it’s also online. Not sure if I have time/motivation for taking part though.
https://frankengamejam.de/
DONE
- The Halle-Spielt App now features timed tasks! Which are just a simple timer with a cancel button; and they’re used for tasks for the players where there is no real way to prove/disprove if they actually did it. So it mostly relies on the honour system, which is totally okay for the scope of the app.
- I updated bloed too. It now has “composite textures”, which means I can have grass blocks which are dirt on the bottom and the sides, but grass on the top. This was possible before, but only via extra side data, which consumes memory. Now there’s a way to automate it.
- Last but not least I further improved the locks in Pry. This mostly boils down to the fact that the naming of the keys/locks is a level-wide thing now, as there are 15 keys maximum anyway per mission. Now I can be (somewhat) sure the naming of “key 13” is consistent with “lock 13”.
2021-09-27
DONE
- I was always a bit unhappy with how the ladders work in Pry, so I changed them to be used like in Filcher - by pressing the “use” button to actually climb them. I’m unsure if it’s the better system, but for now I find it more stable and logical with how the rest of the game works. A bit of work is still needed for this, then I will upload a new version.
2021-09-25
DONE
- I tried to port Terrobot to WebGL, but unfortunately it only worked partially. Apart from the constant spawning of a message about how the post-processing stack only works correctly with fullscreen cameras, the scripting part does not work because apparently some code from the Small Basic interpreter gets stripped away. The error message is “MissingMethodException: Default constructor not found for type ISB.Lib.BuiltIn.” This is a problem for a different time, but it seems to be about Addressables?
https://forum.unity.com/threads/addressables-and-code-stripping-il2cpp.700883/
Last post might be a solution:
https://forum.arongranberg.com/t/unity-2019-1-3-default-constructor-not-found-for-type-pathfinding-gridgraph/6769/8
Update: Yep, after adding this Preserve attribute to the BuiltIn class of ISB, the WebGL build seems to be fine. I submitted an issue on the ISB’s git repository, maybe it helps the developer. - Before I forget it again - as usual the standard settings for Unity web builds don’t work out of the box; the project won’t finish loading. I had to disable compression (Compression Fallback) as the simplest solution for this.
https://forum.unity.com/threads/uncaught-referenceerror-unityframework-is-not-defined-at-htmlscriptelement-script-onload-webgl.803967/page-2 - To get back a bit to Pry dev, I visualized door locks. The plan is to make it more clear that a key needs to be used, but of course the underlying problem isn’t solved yet: How does the player know they have to actually take the key in their hands and “combine” it with the locked door? I think it’s mostly a tutorial thing, but on the other hand I know that the system is maybe a bit alienating to some users. (Even though Deus Ex, Thief and now Filcher require a similar thing from the player.)
In any case, to make it even more complicated, I added some interfaces to allow different charge times - for doors that are “more difficult” to lockpick.
2021-09-24
SEEN
2021-09-23
PLAN
- I might participate in the HaxeJam (starting October 17th), because I like the language and ecosystem, and even the community a bit. I’d probably use either Heaps or Kha, or even Armory3D, but with no plan right now what game concept actually. Depends on the theme.
https://itch.io/jam/haxejam-2021
DONE
2021-09-19
DONE
- I participated in the 13th instalment of Alakajam (the theme was Robots) this weekend - and actually submitted something. Even though for the longest time it looked like I wouldn’t; and really, the game isn’t what I wanted it to be. But it is functional, and shows potential. Which is why I actually finished it up. Terrobot is a programming game/puzzle/dungeon crawler. For the programming part - in order to move the terrobot around - the player has to write small scripts with Small Basic. I decided on Small Basic when I found wixette’s interpreter for this programming language by Microsoft, especially as the interpreter is usable in Unity. It’s far from perfect - for example, there is no handling of syntax errors, the interpreter returns nothing - but it works most of the time. I had to modify the interpreter though, in order to allow asynchronous stepping through the code.
Terrobot is also the first game that uses bloed, my very own level design tool. Not the grandest premiere, but a premiere nonetheless.
https://github.com/wixette/isb
https://smallbasic-publicwebsite.azurewebsites.net/
https://alakajam.com/13th-alakajam/1167/terrobot/
https://ratrogue.itch.io/terrobot
SEEN
2021-09-15
SEEN
2021-09-14
SEEN
2021-09-10
SEEN
2021-09-09
SEEN
DONE
- The Patou puzzle-prototype is finished for now as the deadline for the application for the federal state funding is today. I think it can work in third-person view, but if not then a change to some aerial view wouldn’t be too bad either. Right now the puzzle is just about sliding some boxes along other boxes to a goal, or build a bridge. The potential is big enough to add more interesting and compelling elements though.
https://www.youtube.com/watch?v=GwzPFX14Mn0 (top secret!)
2021-09-08
SEEN
2021-09-07
SEEN
- I watched - over the course of a few weeks - an Unreal 4 tutorial which basically teaches how to navigate the editor, how materials work and can be manipulated, a tiny bit of Blueprint, and mostly how to create a landscape with Megascans. Overall I didn’t really get warm with Unreal through this course, mostly because I am very overwhelmed by the amount of options.
https://www.youtube.com/watch?v=_a6kcSP8R1Y - Robert Yang’s “Quake Renaissance” articles for Rock Paper Shotgun were quite nice. I am playing through the game currently and even though some stuff didn’t age well, I would say it’s better than Quake 2 overall. So Yang’s article helped me to understand the game and the culture around it, which is kind of valuable when you’re a game developer.
https://www.blog.radiator.debacle.us/2021/08/quake-renaissance-for-rock-paper-shotgun.html
2021-09-05
SEEN
- A few “Simplest AI Tricks”, although of varying quality. I like the idea of using breadcrumbs spawned by players to teach AI enemies where and how to wall-run. Bonus trick from the comments: “make the bad guys run away sometimes, not necessarily for a discernible reason. It worked for Clyde in Pac-Man, it worked for the Grunts in Halo, it sometimes leads players into a worse situation and seems really tactically clever... just make them run away and/or hide a bit sometimes.”
https://www.youtube.com/watch?v=iVBCBcEANBc
2021-09-04
DONE
- I semi-solved a bug that was annoying me for weeks or longer in Pry (even though we don’t really work on the project anymore). When an enemy ran to the player and attacked them, often the enemy would slide quite a bit before coming to a halt. Turns out that the acceleration setting of the RichAI component was the culprit. Increasing it to a high value like 10,000 helped, but caused another problem - such a quick acceleration would look janky in other situations. So I had to add some logic to set the acceleration to this high value when stopping, but easing back to the original value over a short timeframe. It feels a bit dirty, but I guess things like this aren’t really solvable without a hack.
2021-09-03
SEEN
2021-09-02
DONE
- I did several smaller things for the Halle-Spielt App, mostly graphical improvements and UI work. I also added a rudimentary main menu. Due to health problems in the family I can’t do much currently, but I hope my productivity increases soon.
2021-08-26
SEEN
2021-08-24
SEEN
2021-08-23
SEEN
- Watched a talk by Aubrey Serr about Radically Non-Linear Leveldesign. Nothing really new for me - I guess reading/watching stuff about Thief levels already (and trying to make our own Thief-like) already gave enough insights.
https://www.youtube.com/watch?v=CTBor4rhnQs
DONE
- One of the “mini games” for the Halle-Spielt App is finding a spot on the map by actually walking there - of course with the help of GPS. For that I define the latitude/longitude coordinates of the cache and also a radius (in meters) which indicates where it could be, so you’re not totally blind trying to find it. What I found interesting is that the formulas for converting lat/long into meters have the magic number 111,111 in them.
2021-08-20
DONE
- I’m currently working on a small puzzle prototype for our maybe-next game project Patou. It has a lot of premises it has to fulfill, so I am very limited in what the puzzles will actually look like. First, it has to work in third-person view, second the puzzles shouldn’t get too complex and third the dog character in the game has to be able to play an integral part of each puzzle.
2021-08-19
SEEN
2021-08-16
DONE
- The Halle-Spielt App now has a beginning and an end. Which means the story creator can add some kind of introductory text, and also one for when the story is finished. On the negative side I noticed that the update for the QR-code scan plugin doesn’t work anymore, at least for me.
2021-08-15
SEEN
- Watched a short introduction to Unity’s new UI Toolkit (or whatever it is called now). It’s basically CSS and a bit of the old IMGUI. I don’t like how the developer apparently doesn’t get direct references to the elements, so they have to resort to getting elements by string, ugh.
https://www.youtube.com/watch?v=6zR3uvLVzc4 - Noclip did a pretty good Thief documentation, with a lot of interviews and some material even I didn’t know. The gist is: great game design ideas, and crunch is cool if you do it voluntarily. Hm. Other than that I’m sad Doug Church wasn’t interviewed.
https://www.youtube.com/watch?v=8ZmcbShMFNY
2021-08-14
SEEN
- A short video about parasitic (game) design. I didn’t know a word for it, so it was interesting to me. Parasitic design basically are game mechanics that wouldn’t change the game if they were removed. I guess one could compare this to a character in a book, who serves no real purpose in order to advance the story.
https://www.youtube.com/watch?v=xwHJqXKwRKM - LÖVR could be interesting for experimenting with VR without trying to make a full project. It’s basically LÖVE, but 3D and for VR.
https://lovr.org/ - Lots of tutorials for level building. Seems to be Unreal-only.
https://worldofleveldesign.com/ - Some neat things in this Blender video about character creation. The character is ugly though.
https://www.youtube.com/watch?v=hXd4KEqrYEE
2021-08-11
SEEN
DONE
- I added a QR code scanner plugin to the Halle-Spielt App. I used it years ago already with a jam game (“Die Stimmung kippt”), and it’s still working, so I’m thankful for that. I still have to add a lot of convenience things - what happens if the user aborts the scanning, etc. - but the most important step is done: actually calling the right functions. The game still has no logic on what happens if you do the right or wrong thing though, other than maybe give you points. Maybe it’s not necessary to add an actual lose state, as the game should be super easy.
2021-08-09
PLAN
- I currently have a few project( idea)s that I would like to work on, but somehow don’t have the time or the motivation (mostly both) to actually do it. Some of these are:
- Pry: I work on it from time to time on the side, because I always wanted to do my own Thief-like. Current task though would be to work over the AI, and it’s not easy.
- Zauberwald 3D: a text-adventure my brothers and I wanted to create, and while there is no real incentive to actually work on this, it’s still in the back of my head.
- Archeology game: a game idea that I had during an Alakajam, but it wasn’t feasible to do it back then. I still like the idea though, and I might get back to it someday.
- Stealth gridder: I wrote about this a lot already, and the current state is a good basis for building an actual game on it; but somehow I lost motivation to go further, and I have to find out why.
- Fantasy platformer: this is just a stupid idea that might be fun - a game based on my brother’s puppet series. Could be co-op even. If I’d wanted to do it alone, it would be very low-poly, and short.
- Coding game: something like CHIPCODE, but embedded in a 3D world and with a story.
- A game that uses LEDs. I liked working on my little electronics projects, and I think I could pull off something more complicated. Maybe combine it with the Orba, and/or my old RGB gamepads.
- Zoo game: a mobile game for the local zoo. This could actually be a module for the Halle-Spielt App, so here’s a higher chance for one of these projects to become realised.
- Vestbank: a VR game inspired by the C64 game Westbank; basically just a very simple shooter, but you have to take care not to shoot innocent people.
- Create stuff with my cheap 3D printer, like a simple 3D puzzle.
- A standalone version of the dialog editor I created for Behind Stars and Under Hills.
- Tech I would like to find time to dive into: Flax, Unreal, maybe Roblox. More Python. More Blender. Urgh, so much to learn and see and do. And not enough brain power to pull through.
2021-08-07
DONE
2021-08-05
SEEN
2021-08-03
SEEN
DONE
- The Halle-Spielt App now saves (and loads) the game state, which is important for this kind of game, so I implemented it “early”. Next up: some kind of high-score. This is for actually adding some kind of reward/punishment to the mini games.
- I drew a picture, on A4, with pencil. It’s for the “CD cover” of the soundtrack of my brother’s puppet show. It was fun, and as usual I vow to draw more. What’s missing mostly is having some kind of theme or task, otherwise I just don’t do it.
2021-08-01
SEEN
2021-07-31
SEEN
2021-07-30
SEEN
DONE
- Working with longitudes and latitudes for the Halle Spielt App is a bit dry, and testing the stuff is hard, because I’d have to go outside for that... But at least three different quiz types are added now, although they don’t do anything yet. Next up is saving (and loading) the game’s state, especially for the stations. This way I can reuse it ingame when re-visiting a station later.
2021-07-28
DONE
- Doing small things for Pry, treating it like a hobby project. As such I only add/change small things, for example it’s now impossible to use the bow while climbing a ladder. Tiny additions to the statistics screen at the end. Shooting an unconscious enemy kills them. Things like that. What I really should tackle though is improving the AI.
2021-07-27
PLAN
- I should add more stuff to Alternative Artefacts, but somehow I feel drained. It’s not very rewarding to extend it if nobody writes stories for it.
SEEN
2021-07-24
SEEN
DONE
- Even though Pry is “on ice” for the time being, I changed some of the input functionality in the project, because somehow I feel I can do at least that. I’m still interested in this becoming a full game, so I’m still at least a tiny bit committed. In any case, instead of RMB for manipulating hovered items (like objects on the ground, picking them up), it’s now the key F. This leaves RMB free for alternative usage of the item in hand; like cancelling a bow attack, or parrying with the sword. The question remaining is: how will gamepads handle this?
2021-07-21
DONE
2021-07-18
SEEN
2021-07-17
SEEN
2021-07-13
SEEN
- Our Machinery now was released as Early Access, and with a price (pretty cheap, for indies). I might want to try to make my usual box puzzle game with it in order to evaluate this game engine.
https://ourmachinery.com/
2021-07-08
SEEN
2021-07-07
SEEN
DONE
- I’m doing some boilerplate stuff for Halle Spielt App currently, like implementing popup dialog windows and things like that, and it makes me aware that I should make this reusable because I already did these things for the last three contract jobs now.
2021-07-06
DONE
- For the Halle Spielt App, a new side project that is already funded, I looked into how to implement getting GPS coordinates using Unity on an Android phone. We already did this with our Global Game Jam entry from 2019, Wehheim, but back then I used Mapbox, so a lot of stuff was already done for me. After a bit of research - and doing the wrong thing for half a day - it actually wasn’t much code to get it working; now I can receive the current GPS coordinates.
2021-07-05
DONE
- Out of nostalgia, and maybe for Spielgefährten, I installed Ultima 7 from my floppy disks (around 30 years old now) on DOSBox. The installer didn’t continue at first, but I found out I had to reset the disk caching, by using Ctrl+F4. No idea why, but it worked that way.
- I used Blender a bit today to create a 3D model for an art object by my brother Ludwig. It’s not finished yet though.
2021-07-01
SEEN
- A redditor wrote down their experiences when they tried to hire artists. Nice read.
https://www.reddit.com/r/gamedev/comments/oa7dtj/ - Watched a video about hard vs. soft worldbuilding, a topic that currently interests me because of project Pry. I found it insightful, and might change my thinking regarding story creation a bit.
https://www.youtube.com/watch?v=gcyrrTud3x4 - I read this tutorial for ceramic, a 2D engine for haxe. It works a bit like Kha, as it creates a full self-contained installation of all needed libraries. Which is something I’m not a fan of, but I guess it has its advantages. Anyway, what I’ve seen in the little tutorial project is nice enough and easy to understand, so I might use it for a project, at least for a 2D jam game.
https://jeremyfa.com/getting-started-with-ceramic/
DONE
- I extended Pry’s revamped interaction component so it also supports “infinite continuous interaction” now. This is useful for stuff like turning wheels, charging stations, maybe some fun throwaway interactions.
2021-06-30
DONE
- There are now items that can have texts in Pry. So the player can either right-click the object and get the same read interface as with the signs, or they can keep the right mouse button pressed and thus collect it. For this I had to do some heavy changes on how interactable things work, but it was all for the better. Consumables will benefit from this too (either eat it at once, or collect it). I think Prey (2017) has the same system, so I was inspired by that.
2021-06-29
SEEN
DONE
- To counteract the effect of lifeless (unconscious) enemies dying too quickly when the Pry player throws them around, I gave them a simple auto heal effect. Not very realistic, but it makes it harder to kill enemies accidentally, while they still suffer death from falling great heights.
2021-06-28
SEEN
DONE
- Some strange problems arose with a custom editor in Unity, where deleting a sub asset wouldn’t actually remove it, and I have no idea why. As a workaround hack I added extra checks and anytime the custom editor notices that there are some invisible sub assets, it tries to remove them. Ugh.
- Currently I’m trying to make unconscious enemies (knocked out by Pry) vulnerable to damage. This is somewhat complicated in the case of fall damage, as there doesn’t seem a good simple way to measure how much certain collision events should hurt. I guess it’s a matter of trying around. In any case my current approach kind of works, but makes it clear I need to generalise it a bit more - this would even be beneficial in order to add vulnerability based on different body parts. Head shots would be possible then.
2021-06-24
DONE
- After adding the tutorial signs to Pry’s playground test level, I now try to make enemies who were knocked out by the player more meaningful. It’s especially important that they die when you hit them with an arrow, or push them into an abyss because of the impact. Easier said than done. Anyway, the reading interface works well and we can even add pictures to the texts. The usual localisation code is utilised as well.
2021-06-21
SEEN
- Noticed that I can’t select UI elements anymore in my Scene view… apparently because Gizmos were not active! The hell!
https://answers.unity.com/questions/1653266/ - Remember, when using TMPro.TextMeshProUGUI in a Vertical Layout Group, use a Content Size Fitter with Vertical Fit set to “Preferred Size”!
DONE
- Currently working on an interface to read stuff for Pry. Because it’s about time we add some text messages, and hint at some story!
- I wrote a design document for our next demo level. While it was a bit tedious, we should probably do something like that for every single mission in the game.
2021-06-18
SEEN
- Finished watching a tutorial video about modelling and sculpting a stylized head/bust in Blender. It actually taught me some new techniques, especially the stuff with remeshing, so it was pretty interesting.
https://www.youtube.com/watch?v=KsDe1V9Dl-0
2021-06-17
SEEN
DONE
- Pry now has a zoom tool that can be used to decrease the field of view of the camera, thus giving the illusion of a zoomed in view. Very handy for thieves and spies! Of course, this is very rudimentary for now, with placeholder optics and so on, but it works quite well so far.
2021-06-16
DONE
- While it’s nothing special in itself, Pry now displays the current version in the top right corner, and if it’s different from the version on the server, it will show that too. What’s noteworthy about this? I updated my StoneBuilder script so I can automatically upload the most current version (as a text file) to the server without me having to do manual steps.
2021-06-13
SEEN
- Saw the documentary about Axiom Verge. Pretty crazy that the guy did all the stuff for the game, even the music. Got pretty sad about what happened to his son (who was born after the release).
https://www.youtube.com/watch?v=mWgmPkR1wwU
DONE
- I did some more work on the ladder in Pry, as the playground demo made it clear that automatic climbing isn’t the way to go. Because if you just want to peek over the edge (as there is a guard patrolling), you climb up into full light instead. So now I removed the automatic climbing, which makes leaving the ladder a bit more complex - which means I have to get back to it sooner or later.
2021-06-12
SEEN
- This tutorial explains how to get rid of strange rotation and scaling when you export a Blender model to FBX and import it into Unity. Basically, uncheck “Use Space Transform” when exporting (available since Blender 2.91) and check “Bake Axis Conversion” in the importer options (since Unity 2020.1).
https://polynook.com/tutorial/how-to-export-models-from-blender-to-unity/
2021-06-10
DONE
- I will call Guarden from now on Pry, even though that’s not the final name either - but it might be the name of the protagonist. It fits more than “Guarden” anyway.
So I improved the hacking device a bit - it got some fun effects (all rudimentary for now) - and battery. The battery can be charged at a special station. We’ll see if this is a good idea, but overall I’m all for limiting tools so the players have to be more tactical.
https://ratrogue.tumblr.com/post/653683352261509120/ - We gave an interview in our office today, for Halle Spielt. One of our better efforts to (re)present Rat King, I must say.
2021-06-09
SEEN
- Read this article about The Art of Lighting Game Environments. It uses Unity’s HD Render Pipeline, but can be applied to other software and render pipelines. Overall I didn’t learn much new, but it’s nice to see the HDRP is actually using the same stuff as before.
https://cgcookie.com/articles/art-of-lighting-game-environments
DONE
2021-06-08
DONE
- Added some finishing touches and fixed a few bugs, and now Guarden’s playground demo is ready to get sent to testers. There are not a lot of them yet, but I wouldn’t want to have too many eyes on the game for now anyway. I know about pretty much all of the obvious problems it has. Still, it would be cool to see if there are people actually interested in a Thief-like.
2021-06-07
DONE
- Guarden finally doesn’t rely on hard-coded missions/quests anymore - instead I programmed ScriptableObjects that do the very same job, but can be created for each level individually; maybe even for different difficulties.
2021-06-06
DONE
PLAN
2021-06-05
DONE
- I set up an itch.io page for Guarden, so we can distribute it to testers when the time comes. The name of the page is, for now, “Pry - Steel and Stone”, because “Guarden” wasn’t fitting anymore for months now. Of course building the game to an .exe made some bugs prominent, so first I had to fix those. After that comes the polish face for the playground - which basically means that I will distribute loot and other items, and define the mission better.
2021-06-04
DONE
- I wondered quite a bit why, in Guarden, thrown objects would jitter so much when I move the player/camera at the same time. Seems I forgot to change the Rigidbody’s Interpolate value. The internet says the value should be “Interpolate”, but so far the jitter really got removed only with “Extrapolate”.
- For a bit more “juiciness” I also added some small camera roll when the player moves left or right. I think it looks awesome, but it might be annoying for some.
2021-06-03
DONE
2021-06-01
SEEN
DONE
- I’m currently working on some kind of dynamic help system for Guarden. It mostly consists of signals that the different components can broadcast. E.g. the sword, when pulled out, just broadcasts a signal INPUT_BUTTON_ADD with the values “LMB” and “Attack”. Of course, this has to get improved later, to accommodate gamepads and rebindable controls.
2021-05-26
SEEN
2021-05-23
DONE
- I removed the Collab integration of Guarden, because honestly it annoyed us more often than it should. Instead I tried to export the repository because I wanted to use the data for a GitHub repository of Guarden. Unfortunately it wasn’t usable for us, but thankfully a full development history isn’t that important to me for now. This might change later. In any case I am trying out the GitHub for Unity plugin, even though the reviews on the Asset Store are far from positive. But as we don’t use most of the functionality it might be a boon nonetheless. In any case I need to look into GLFS (Git Large Files Storage) sooner than later.
https://unity.github.com/ - Among some small changes the crouching in Guarden is now a toggle. It will probably be an option later on, when we have a menu for that.
2021-05-19
SEEN
- The 52nd entry of Jackson Dunstan’s series “C++ For C# Programmers” is a list of best practices in C++, and it really was interesting to read. Especially with my extremely rusty C++ knowledge.
https://www.jacksondunstan.com/articles/7139
DONE
- I could make the ragdolls in Guarden much more stable now. One reason they always behaved like goo was that I put the ragdoll colliders into a physics layer that doesn’t collide with itself. Another very helpful thing was just using PuppetMaster, a plugin by the FinalIK developer. PuppetMaster is actually pretty powerful for dynamic ragdoll functionality, and a bit of an overkill for our project. But for now it works much better than before, and maybe we will use some of the other features of PuppetMaster.
https://assetstore.unity.com/packages/tools/physics/puppetmaster-48977
2021-05-17
DONE
- Apart from doing smaller things for Guarden, like adding support for methods with an integer parameter to the Hacking attribute, or increasing the senses (view distance, angle, etc) of AI agents that are suspecting or follow a target, I again tried to improve the stability of ragdolls the player throws back into the world after picking them up. Apparently I am not the only one with this problem, and it seems one culprit at least are the joints that have to get reset somehow, otherwise they have old and now invalid values in all the wrong places.
https://forum.unity.com/threads/cleanly-resetting-a-ragdoll.202510/
https://forum.unity.com/threads/resetting-ragdoll.247435/
2021-05-16
SEEN
2021-05-14
DONE
- The player can now grab stuff and move it around in Guarden. This isn’t as sophisticated as it was in TRI, as the physicality of the system back then is not needed or wanted; instead a much simpler system akin to Thief was implemented. Right now it only works for bodies of enemies, but it would be no problem to extend it to crates and similar stuff. It still needs some kind of collider check though. And the bodies behave very strangely; I gave them a special “throw pose”, but the main problem is the fragility of the ragdolls.
2021-05-12
DONE
- As Guarden’s enemies notice corpses of other enemies when walking around, it would be bad if the player wasn’t able to carry dead bodies around. Now they can do that. There are problems with the ragdolls though, which are not that important for now.
2021-05-11
DONE
- My brother is getting another trailer from me, for one of his exhibitions. This time I’m not doing it in a video composition program (I mostly use Hitfilm Express), but in Unity, because he wanted it to look like a cracktro. A nice idea, and scripting this instead of animating it feels more natural. Most elements are done for now, but here and there will be corrections to the timing.
http://www.kunstvereinkohlenhof.de/matrix/ludwig-hanisch-malerei-installation
2021-05-10
DONE
- It’s probably a quite brittle system, but guards in Guarden can now “remember” corpses lying around - so they won’t get alerted by them forever anymore. It’s actually not really bad if they do, but in the end the game should at some point return to a “safe state” because otherwise it feels unfair.
2021-05-09
DONE
- I added some rudimentary path-finding code to my gridder. It’s not used yet for anything. The important part is that AI agents should determine if they can use doors or not, even if they’re currently closed.
2021-05-08
SEEN
DONE
- I did an overhaul of how the new AI agents in Guarden look at things. It’s not finished yet (as usual), but the gist is that I removed “rotating body/head at a target” from the agent’s move module and made it an integral part of the agent class. Unfortunately there are still some problems, and not everything is absolutely clear. I especially dislike how I coupled the rotation behaviour to the current state, and I will most likely change this.
2021-05-07
SEEN
- Interesting way to see Unity’s internal editor functions: “Create an asmdef and call it Assembly-CSharp-Editor-testable.” (The functions are internal because they are not documented, because they can change anytime.)
https://twitter.com/sh4na/status/1374446599435214850
2021-05-05
PLAN
SEEN
- Had a look at C# 8.0’s new features, and while some of them are interesting, I am not sure I will use them in the near future. Especially as Unity does not allow all of them.
https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8 - I’m still pondering about switching Guarden from the built-in render pipeline to the Universal RP, but of course the fact it’s only forward rendering (which means: it’s not possible to have a lot of dynamic lights at the same time) is the main reason we won’t do it. As there is a deferred renderer in the works, this might change. But then again I skimmed over this (fairly old) article about Forward+, comparing it to Forward and Deferred, telling me that we should wait for Unity to get to that one. And who knows how long this will take.
https://www.3dgep.com/forward-plus/
DONE
- As Jana wished for an enemy who can look from above, from some kind of balcony or so, and attack the player as soon as they see them, I worked on that. It’s really frustrating what a can of worms that is, even though Guarden’s new AI mostly works. But there will always be strange and unsolvable edge cases.
2021-05-03
PLAN
- Someday I really want to release a gridder, so I had a look at my old TODO list of the last iteration of it. Seems doors were very important to me, so I outlined how to implement them. Making them interactable for the player is the easiest part; it becomes more interesting when enemies should be able to use them too. So there should be connections between the way points that have information if they can be enabled by doing an extra step.
DONE
- Guarden’s enemies can now switch to far-range weapons if their enemy (i.e. the player) is too far away. Not perfect yet, but it’s working. Main problem is the fact that they switch weapons instantly without any animation, so this looks a bit strange.
2021-05-01
DONE
- I kind of solved the new, modular AI’s problem with the alarm buttons. AI agents of Guarden can tell other agents “facts”, which are just single strings for now, but with a time constraint. It’s definitely not the most robust system, but somehow I feel that a little “wonky” AI can create funnier/unexpected moments, and that’s probably more important anyway.
- I fixed a tiny bug in bloed that prevented it from working with Bakery - as I added a NotEditable hide flag to each chunk, the lightmapper didn’t find the objects. So I removed this hide flag. It’s still not enough to warrant an update of the editor on itch.io, especially as less than 20 people actually purchased it.
- As I actually wanted to do a game this weekend (but didn’t), I opened my old gridder project and fixed a bug with the player being able to climb sideways. At least this won’t annoy me now. (The actual plan for the weekend was a very simple game with only a single level and a single enemy.)
2021-04-30
SEEN
2021-04-29
SEEN
PLAN
- With a free weekend to come, I wonder what I should do. I have several projects still open that I’d like to pursue, but most of them are not really weekend material. Like, one idea would be recreating my dialog editor (for Behind Stars) as a standalone tool, maybe using Dear ImGui, and its C# wrapper.
https://github.com/ocornut/imgui
https://github.com/mellinoe/ImGui.NET
DONE
- While we’re fleshing out the story of Guarden, I still work on the AI from time to time (which will be the case for, probably, forever). Now the AI agents can activate alarm buttons if they feel there’s danger. The problem though: they all run to the button at the same time; so I need some kind of blackboard for enemy groups where they can add infos, like “agent X is going to activate this alarm”.
2021-04-27
SEEN
2021-04-22
SEEN
- Interesting tool for curve fitting. Not sure yet for what I’d need it, but looks useful of course.
https://mycurvefit.com/
2021-04-21
SEEN
- Interestingly enough Unity Tech wants to add support for Enlighten’s real-time global illumination to URP in the later versions of Unity. After they said they would remove Enlighten completely from Unity 2021 and beyond. It’s really bad how much they’re behind with their own tech so they can’t deprecate stuff as planned.
https://forum.unity.com/threads/update-on-global-illumination-2021.1067015/
2021-04-19
DONE
- Today I tested Bakery’s settings and generated lightmaps, in combination with the Universal Render Pipeline of Unity. This works so far, although I still miss the real-time global illumination of Enlighten. Anyway, things got strange when I changed the forward renderer of URP to the experimental deferred - suddenly everything became grey. I guess this needs quite more time before it’s actually usable.
2021-04-16
SEEN
- Watched another Blender video, this time about one hundred add-ons. I’m not sure why I watch these videos, but they are kind of entertaining, and in the end it’s a good idea to know what the software actually can do.
https://www.youtube.com/watch?v=n9nWAuKat60
DONE
- While fixing a few bugs with the “new” AI in Guarden, I noticed a big problem with how the enemies react when getting suspicious because of some sound. There are a lot of cases where they would walk stupidly in exactly the wrong direction, because, of course, they are suspecting and don’t have a clear target. There’s also a problem with pathfinding, but this is just an amplifier. I will try to find ways to solve this later, when we actually build stuff.
In the end the problem might solve itself when I make the detection angle and radius more dynamic. (For example increasing the sense radius when suspecting a sound.) - Furthermore we worked more on the new story/plot, and it’s actually the first time since the inception of Guarden as our new project that I am quite content with the direction our story ideas are going.
2021-04-15
DONE
- Had a problem today in my code where something that became null wasn’t recognized as null. Of course this was because of Unity’s Objects being able to be destroyed but still not null internally. So I have to check thing == null || thing.Equals(null) on my interfaces from now on.
https://answers.unity.com/questions/586144/destroyed-monobehaviour-not-comparing-to-null.html - The “new AI” of Guarden is done now, as in: it’s now a complete copy of the old functionality, just spread out over several classes instead of just one. Next step is to put the modular design to a test and extend it with interesting things like: pushing alarm buttons when a threat is near; detecting (and reacting to) dead bodies of friends; attacking foes that are not the player. And so on.
2021-04-13
DONE
- More work on the “new” AI of Guarden (which is still only a re-implementation of the current behaviour) - it now can potentially sense multiple targets. Choosing the “best” one is not really implemented yet, but that is only a matter of time, and when we need it. I also could make attacking the player more general by just playing the animation and letting animation events do the rest.
2021-04-10
SEEN
2021-04-09
DONE
- Just to see if we can use it for Guarden maybe, I tested Unity’s Universal Render Pipeline - with deferred rendering. Deferred rendering is still experimental, not officially supported, but what I saw did work at least. (I had to update to Unity 2021 for that, because it didn’t work in Unity 2020 LTS.) The amount of draw calls is pretty high though, even higher than with the old in-built render pipeline, so I am not sure if a change will be a good idea. Only actual performance tests will tell the truth.
2021-04-08
SEEN
DONE
- Still working on Guarden's AI - and this will go on for another month is my guess. I am back and forth on how to distinguish between a “suspecting” state, and the actual “sensing something and following it”.
- We also discussed the story of the game a bit; while this is also a big construction site for the foreseeable future, at least we’re very happy with its current direction.
2021-04-06
DONE
- During Easter I mostly worked on Guarden’s AI, as planned for a long time. The current state of the new code is “barely working” and “extremely unfinished”, but at least I could separate some of the original code so there won’t be a monolithic Enemy class anymore, but a GameAgent that can have several components responsible for animation, movement, etc. Hopefully I can keep this up till the end.
2021-03-31
SEEN
- I watched a video about optimizing physics performance in Unity. It actually contained stuff I didn’t know before, especially things they added in recent Unity versions. For example, you can change the solver iterations per rigidbody. The raycast command API is interesting too, although the last time I tried it it didn’t fit my use case unfortunately.
https://www.youtube.com/watch?v=pTz3LMQpvfA
2021-03-30
SEEN
2021-03-29
SEEN
- I read the two PowerPoint presentations by Randy Smith, namely "Design Fundamentals of Stealth Gameplay in the Thief Series" and "Level Building For Stealth Gameplay". They still hold up. Later that day I also read "How To Help Your Players Stop Saving All The Time", even though it’s probably not that applicable to Guarden - a highly interesting read nonetheless.
A day later, I read “Practical Techniques for Implementing Emergent Gameplay”, and while Guarden already follows some of the proposed techniques, it was still a good read.
http://www.roningamedeveloper.com/Materials.html
2021-03-27
SEEN
- While Guarden still uses the legacy render pipeline, which is very outdated nowadays, I saw that there are efforts to bring deferred rendering to the Universal Render Pipeline. Which would be awesome, because “infinite amounts of lights” is what the game needs the most. Hopefully it’s coming soon enough.
https://forum.unity.com/threads/urp-deferred.931872/
DONE
- I wrote a blog post about bloed; which is pretty much the pinnacle of my PR efforts for this tool.
https://ratking.de/blog/2021/03/26/bloed/ - Enemies in Guarden now have foot steps. At first I tried to use animation events for this, but as I blend idle, walk and run animations, this wasn’t feasible. In the end I now check the Y position of each foot and if it’s below the start position, it checks the floor’s properties and the correct sound is played. Works well enough so far.
2021-03-25
DONE
- As enemies in Guarden got startled by their own actions (namely: closing doors) because of the sounds, I added some kind of “ownership” to incidents like this. So now they can distinguish between sounds caused by the player and sounds caused by anything else, which removes the problem. I put the info of by whom it was caused, and when, into a class SignalInfo, and this is probably not good for performance (because it needs to get garbage collected at some point). Changing it to a struct might be bad too though, because the info gets copied for each receiver. Ugh, decisions…
- Finally added a few missing projects to my website.
https://fholio.de
2021-03-24
SEEN
2021-03-23
SEEN
PLAN
- I am still working on that “perfect” behaviour tree for our Guarden NPCs. It’s pretty much an AI agent from Thief so far, but I’m okay with that, because those were fun to play with.
2021-03-22
SEEN
- Finally read an article on The Digital Antiquarian, about System Shock 1. A great game, ahead of its time, as they say.
https://www.filfre.net/2021/03/system-shock/ - Finished reading a book about - writing books. Not that I really want to be an author, but I toyed with the idea of writing something from time to time. I know I should be much more active to actually do it. I have that problem a lot with other creative things too, like drawing or composing music - I am interested in them, but I don’t have the energy to master these things.
PLAN
- For Guarden I need to make the AI of the enemies more robust, especially as I’m coming up with things I’d like to add, and of course with a growing list of things that are broken or don’t work in specific cases. I still want to use behaviour trees, and I’m slowly accepting that I still have to use “states” with them. Maybe I should just rename them to something else, like “condition”, so if the enemy notices the player, they get into the “attack” condition. No change actually, just in name. In any case I am filling a document with how I want the behaviour tree to look like, and it’s not a big difference to what it is currently, but here and there I see room for improvement.
- Mozilla Hubs is really nice for a different kind of chatting, so we want to do a Rat King hub someday.
https://hubs.mozilla.com/
DONE
- An interestingly complex problem in Guarden currently is picking/hovering items that are attached to enemies. As the enemies have a bounding box (a capsule actually), the item has to “float” a bit detached from them, because otherwise the hover raycast will pick the enemy, not the item. I tried various things to solve this differently, but I actually didn’t find anything that would work correctly in all cases.
2021-03-18
DONE
- I improved the sound “hearing” of the enemies in Guarden, by giving each sound an “importance” factor, so the suspicion of an enemy raises slower for certain sounds than for others. Fixed one or two bugs with my SoundType class on the way. (I should commit them to my jam base code.)
- For Jana I printed a little box for her nose piercings, but unfortunately the lid doesn’t fit. Back to Blender, I guess.
2021-03-17
DONE
2021-03-16
DONE
- Tried to fix some really nasty bugs with my Guarden propagation code, which was bad in a lot of places, but mostly in the pathfinding section. Had to resort back to this A* tutorial that is still one of my most beloved tutorials I ever read.
http://csis.pace.edu/~benjamin/teaching/cs627/webfiles/Astar.pdf - Writing down a plan for a talk we will give in two days. As usual it’s about personal games.
2021-03-15
DONE
- Found out why the 3D printer didn’t connect via to my PC, and also found out how to solve it. So, the solution is to search for “wch.cn ports 3.5.2019.1”, download this driver and install it manually. I think the main problem is that I suppress driver installation on my laptop (because of certain problems with stupid microphone drivers that get downloaded and installed automatically).
- I uploaded bloed on itch.io. I won’t do much promotion for it, probably.
https://ratking.itch.io/bloed
2021-03-14
SEEN
DONE
- Finally I did what I wanted to do for weeks now, I made a video for bloed. Of course everything that can go wrong went wrong (sound problems, my stuttering, screen too bright, bugs, etc), but I am not in the mood to fix the errors or do it again, so there it is. Maybe in the future I’ll try another video. Tomorrow: releasing version 0.5 on itch.io and listening to the crickets.
2021-03-13
DONE
2021-03-10
SEEN
DONE
- I added footstep sounds to the player in Guarden, which made me realize the AI sensing and propagation needs more work. Mostly because enemies hear the player too well, as there is no info of how “suspicious” a sound actually is. Walking on metal should have a suspicion factor of 0.8 I guess, wood maybe 0.5 and carpet should be at 0. Something like that. That means I need more data, either via ScriptableObjects, or maybe a database.
2021-03-08
SEEN
2021-03-07
SEEN
2021-03-04
DONE
- I’m working on a system for sound propagation in Guarden. With my naive approach I can define rooms (with one or more points), and connect them via portals (usually doors). For now this works well enough, although in the future I want to be able to define the “penetrability” of a portal, and also implement some A* algorithm for the propagation; otherwise it is not “realistic” enough. The main problem with my approach so far is that it isn’t automated - every room has to be prepared by the designer, and things can go wrong in that case...
2021-03-02
DONE
2021-03-01
SEEN
DONE
- As an experiment I changed the parry button of Guarden - it is now the same as the sprint button. When the player is standing still (more or less), has the sword equipped, then they would parry on the press of the button. Otherwise they increase the movement speed. This is just so I can change the parry button to drop/throw, which I find much nicer.
I also finally started with making the hacking device a bit more useful, but there’s still a long way to go. In any case every hackable thing can have more than one function to hack, and it will be displayed in the device instantly. Using the device will now make the player stop - they can’t move as long as they hack. I don’t like this solution much, but it’s the most real-time one I found so far.
2021-02-28
DONE
- I started my entry for the current Alakajam (theme is “Ancient Ruins”), because during my self-imposed computer-free time during the whole Saturday I actually got a good idea for it. But I do it relaxed, because I am sure I won’t finish, and the vision of the game is grander than a jam game, even though it is fairly straightforward. I like the game idea enough to try it later on again.
2021-02-26
PLAN
- A semi-regular development update in a voice channel inside our Discord server could be fun. Just to get more comfortable with sharing stuff, and talking about it. We don’t have a big audience, so it would be really for the practice, not anything else.
SEEN
DONE
- I extracted the code for throwing items from Behind Stars and pasted it into Guarden. Amazingly it mostly works, though a few bugs remain. And there is the problem of re-using the blocking/parrying key for dropping/throwing items. So blocking probably has to go, because there are not much free buttons on the gamepad left, and it really is only used for the sword. We don’t even know if we will have melee weapons at all...
2021-02-25
DONE
- I extended the existing inventory UI for Guarden, so you have more than just the 8 quickbar slots, but also a full inventory when pressing Tab. You can also swap items between slots. A lot of work to be done, still.
2021-02-22
SEEN
2021-02-21
SEEN
DONE
- The hacking is rudimentarily implemented in Guarden - you can click on something and it changes maybe - but now I found out that UnityEvents can be generic too and have up to four arguments, which is nice. Using it in the Inspector has to be done with care though, because you can still (accidentally) select the method with the parameter to be defined by the user.
https://docs.unity3d.com/Manual/UnityEvents.html - One of the things that annoyed me with bloed is the fact that the prefab workflow is bad because of a bug with Unity (the physics scene gets missing in the prefab view). It means I have to save the asset after every click, and this drags down performance a lot. So I thought I could use this piece of code I found in the forums (by chance) - basically Unity’s own editor-only ray-cast functionality for MeshFilters (instead of Colliders), which means I don’t have to use Physics at all. After some tweaking I got it working, and it actually improves performance a lot. At first I forgot that my bloxel textures can have noise that will move the geometry around quite a bit. I chose to not use shaders for this so the physicality is better, and the noise can have more impact. That meant I cannot use the drawn meshes for the picking, as it can lead to wrong positions, so I had to resort back to the specifically generated colliders - which is a bit sad, because I hoped I can get rid of those too.
2021-02-18
DONE
2021-02-17
DONE
- It’s now possible to knock out enemies in Guarden, via the standard tool “fists”. They also die instantly when they get hit by a weapon if they’re not alarmed. This is all rudimentary; but when I thought about making this another generalized system I noticed that this will be too much of a hassle. For now it works well enough, and is still somewhat extensible.
Ladder functionality is still in the works, too. Because of all the edge cases it will need a lot of time and thinking, and I procrastinate too much while trying to do it. - I published a blog post about our jobs as tutors at our former university.
https://ratking.de/blog/2021/02/17/play-your-self/ - Recorded a video for bloed, version 0.5. It is probably the worst video I could do, but I just don’t feel like putting more work into it. As already stated, I don’t expect anyone finding this tool useful enough, and I also actually don’t want to answer support questions (much). Though an FAQ (if there are any questions) will happen probably.
2021-02-15
DONE
- I started working on the ladder functionality of Guarden, and it frightens me a bit. Mostly because it will make the player’s character controller even more verbose and complex. So the first step actually was to have a look at it again, just to see if I could improve the readability a bit. In any case, being able to crouch, climb, jump, swim,... it makes a character controller very heavy indeed. I have no idea how to break this down into cuter code chunks.
2021-02-12
PLAN
- Something I’ve never done for our first-person games would be having ladders, so this is something I want to implement in Guarden soon.
DONE
- I updated the actual bloed project. Next: some promo material probably, for the itch.io page.
2021-02-11
SEEN
- The next 7DRL Challenge is happening soon! Maybe I’ll participate, if I have an idea for it. It should be short, but in the end it could be the first game for my ray-caster...
https://itch.io/jam/7drl-challenge-2021
DONE
- I updated bloed’s documentation for the upcoming version 0.5. Next step is updating the actual bloed repo, and then making a video.
2021-02-09
DONE
- After, again, fiddling around with Unity’s serialization system I can now define “dynamic variables” for each prefab, scene object or ScriptableObject in Guarden and even merge those variables. Albeit powerful, the system I wrote is very shoddy. In any case it seems to work, as long as I don’t want object references. If the need should ever arise (especially for referencing prefabs), I will have to rewrite it a bit.
Anyway, I can now easily define some dynamic variables for an item type, and overwrite them via an game object instance.
2021-02-07
DONE
- The inventory system of Guarden shouldn’t be the most complex one, but of course it has its own pitfalls, as does every system has that needs to be more or less “foolproof”. So I worked on it a bit this weekend, adding more to the item types, and so on. What dawned on me is how the controls could work. Everything that has to be combined with objects in the world, like keys with doors, can be taken into the hand. Keys would work like weapons this way. So you use it like a sword (left mouse click), and if a door is near, it (maybe) unlocks its lock. With right click you can open the door then. This means, LMB is “using the item in your hand”, RMB is “using the object in the world”. I am not sure yet how consumables will be consumed then, but that will probably be just the key F. (Or vice-versa, with RMB for consumables and F for doors/chests/collectables/etc.) Consumables are items that don’t need to be actively put in the hand because they are not combinable with specific world objects in the same sense as keys. This includes health potions, food, bombs, traps.
2021-02-06
SEEN
PLAN
- Hopefully I can finally release bloed next week on itch.io. I don’t expect that anybody will actually download and use it, but it will be a milestone for me. It might also pressure me into doing updates. In any case I want to use bloed for my still planned stealth gridder. But before I can release bloed I still have to do the following things: a) test it with Unity 2020; b) update the documentation; c) create screenshots; d) make a video explaining the tool a bit; e) copy the bloxels code from my Demon Thief project to the actual bloed project f) update the test level (it’s broken now, because of the changes below); g) decide for a price, if any. Afterwards, h) write a blog entry.
- For Guarden we have some kind of wishlist floating around in our heads, things we’d like to see in the game. This list includes: ladders for the player to use, AI enemies that alarm other enemies, sounds that get propagated through the rooms, a lot of ways to open doors in the game - codes, keys, secret levers... But for now I am mostly “stuck” at mundane things like deciding what kind of inventory we will have. We also have to do a lot more for the story/plot. In any case, for the sound Steam Audio might be something I should have a look at.
https://valvesoftware.github.io/steam-audio/doc/phonon_unity.html
DONE
- We do another weekly live-stream, this one each Friday, where we play stealth games. This is meant as research for our own upcoming stealth game Guarden. So far we did six episodes.
https://www.youtube.com/playlist?list=PLH7V8wJHcWSC8psIQLcunasOCMtmuRxaJ - Overall I did not do enough for Guarden the last few days, because of other stuff going on, stuff that doesn’t actually take time, but is a bit pressing on the mental side. Hopefully karma will balance things out a bit, and soon.
- I did the “last” point on my checklist of things I wanted to do for bloed before releasing it - “optimizing” the extra data for bloxel sides. It now uses a list of integers instead of a dictionary of a side data structure. This probably won’t save much in the long run, but it just feels nicer, especially as dictionaries are not serialized anyway.
2021-02-03
SEEN
- A friend made me aware of a book from 1995 called “Amazing 3-D Games Adventure”, where the author Larry Myers describes how he created a ray-caster engine. This engine was ACK-3D. Which was highly interesting to me, because ACK-3D is the basis (or precursor) of the ACKNEX engine, which I bought and used a lot as a teenager. Ah, fond memories. So I researched a bit and found this fun article about fixing bugs in code decades old.
http://blarg.ca/2019/10/20/amazing-3-d-games-adventure-set/
2021-02-02
DONE
2021-01-31
DONE
- The ray-caster is far from finished, but as the deadline was only minutes away I uploaded it. Instead of a game it’s a sandbox for now where people can edit the only level it has. It is not possible to save it though. The full Sunday was dedicated to adding a working ingame editor (via zui). That means you can walk around and change the level in first-person. I actually didn’t have time to offer all the features “rc-test” supports - individual wall textures are not possible to edit for now. The current state will be confusing for users anyway.
I am interested in taking the ray-caster further and maybe create some jam games with it. Hopefully I don’t forget about it. Best of all though: finally I have some time for other things.
https://alakajam.com/9th-kajam/1045/rc-test/
2021-01-30
DONE
- As this is the last day I have for my ray-caster, I thought I’d try to add portals, because this should be fairly easy with ray-casting (more or less). As the first step I replace differ, a fine collision library for haxe, with my own code, because differ does not support collision with line segments, only with polygons and circles.
2021-01-28
DONE
- It’s always “fun” to find out what tiny thing is causing problems next. This time it’s the fact that Unity does not have a diff tool on its own for the Collab stuff, and all of the third-party tools recommended come with problems on their own. Some of them have to be paid, others (TortoiseSVN) install more stuff than needed, WinMerge doesn’t get recognized. But at least I found a forum post that explains how you can add WinMerge as a custom tool, so I’ll try that next.
https://forum.unity.com/threads/bug-invalid-command-line-using-collaborate-and-winmerge.603064/ - The “ZwölfElf” room game, a collaboration between our students, is finally playable on itch.io.
https://mmvr.itch.io/der-12-11
2021-01-27
SEEN
DONE
- After downloading Visual Studio, which was around 10gb, and some unforeseen problems with images and divide-by-zeroes, I finally created a working windows build of the ray-caster. The colours are all wrong, but other than that this means I could create a level editor for it without having to use a third-party tool or another framework. The question is if I will have the motivation and time for that.
- For Guarden I delved into my character controller code (which is basically what was created for Behind Stars) and tried to add duck climbing. It’s a bit of a bigger hassle than I thought, mostly to get it working with higher ledges.
2021-01-26
SEEN
2021-01-25
SEEN
DONE
- I fixed the usage of the doors a bit, originally created for Demon Thief, now for Guarden. Of course doors are a big hassle in games, so I know this is not the end of it, but for now they are usable enough; I just need to implement the usage of keys.
- Optimised the ray-caster a tiny bit. I rendered the top/bottom walls behind other top/bottom walls even when there was a centre wall in front of them, this is now fixed. I also had an idea for the actual gameplay, but I think it’s too much work for the rest of the week.
2021-01-24
DONE
- Users of bloed (if there will be any some day) are now able to change the chunks’ size from 8 to any value between 4 and 64. It’s not really tested, but it should work.
- Although I am still not sure how a release (for the game jam) of the ray-caster will look like, I added bottom walls too.
https://twitter.com/RatKingsLair/status/1353411491765096454
2021-01-23
DONE
- I added top walls to my ray-caster, but my heart isn’t really in it anymore. I guess I will continue to work on it from time to time, but for the game jam it won’t be a game release, more of a tech demo.
2021-01-21
SEEN
DONE
- I prepared the repository (residing on Unity Collab only for now, github will most likely follow) of our current game project so Jana can use it too and add test levels. This happened before already, but now we upgraded the Unity version and actually use almost everything from Demon Thief. I also created documentation for all things related to the project and the scenes’ hierarchy, so hopefully there will be less problems.
For now the code name of the project is still Guarden, even though we do not actually use the “Gardening game + Thief” idea anymore. It still will be a Thief-like, but with a “Berlinpunk” setting. My fear a bit is that it will remind of NEON STRUCT a lot, but then again that one is sci-fi. - To make bloed’s bloxels a bit more general I removed all references regarding sounds in the bloxels. Users should define their own reactions (sounds when walked on, when hit, etc.) via tags and template variables.
2021-01-19
SEEN
- Another day, another student’s project; this time Unity, but with the Universal Render Pipeline. I didn’t know, but apparently the URP comes with its own special post effects. It was also “interesting” to learn that shadows on terrains don’t work if the Shadow Cascades are set to 0 instead of 2 or 4. (It’s a bug, who’d have guessed.)
2021-01-18
SEEN
- Saw the inners of a student’s Unreal project. Blueprint was pretty intimidating. I guess if we ever get around trying out Unreal, I will directly go to C++, because I don’t see the benefit of Blueprint and its bad overview and even worse sense of structure. Unfortunately - I definitely like node-based scripting, but here I just don’t feel the positive side.
2021-01-17
PLAN
- Now that I potentially know how to implement collision for the ray-caster, I am not sure what to do next for it. I know I need some kind of level format and editor to actually make meaningful content for it. But mostly this is an experiment for me anyway, and I like the infinity stuff already, so I should concentrate on that, maybe just making levels that are nice to look at.
DONE
- For our new game project I basically took what I did for Demon Thief and upgraded it to Unity 2020.1, and tried a few different assets. While I kept returning to PandaBT after trying NodeCanvas once again (very briefly - it will always feel much too bloated now), I will have to use Aura2 instead of HxVolumetricLighting, because the latter one is now officially deprecated. Too bad, I really liked the visual result of it. What I also want to change is to use FinalIK instead of LookAnimator - not because LookAnimator is bad, quite the opposite, but because I want to have a certain limit for the amount of third-party assets we’ll use. Having one asset (FinalIK) that does a lot of different things will always be better than one specialized asset; even though FinalIK’s LookAtIK and AimIK are definitely more difficult to use so far. But FinalIK also integrates with PuppetMaster (because it’s the same developer), something I plan to use for the ragdolls from now on.
https://assetstore.unity.com/packages/tools/physics/puppetmaster-48977 - Seems like the bug with UVs getting strange got me again in bloed. I now removed the functionality to update UVs only (instead of the full mesh), even though this degrades performance a bit in certain cases. Unity strikes again!
2021-01-16
DONE
- After following a very bad tutorial and going nowhere, I chose the lazier path and added differ to my ray-caster for collision and resolution. It works quite well with the walls so far even though it could probably be optimized by supporting a grid-based world map. Collision with sprites will be next. After that I will have to think of either a simple level editor, or at least a readable and powerful level format.
https://snowkit.github.io/differ/
2021-01-14
DONE
- I semi-solved my problem with the sprites not being drawn by just adding all the neighbour tiles to the list of things to draw. This is “semi” only because I didn’t test it yet for enough
2021-01-13
DONE
- I added sprites to my ray-caster by following the aforementioned tutorial, and I’m still working on them so that they can be seen in “infinity”. This mostly works already (even though with bad performance), but there are edge cases where sprites don’t get drawn even though they should. The reason is that I collect all tiles with sprites on them during rendering the walls; which means that hidden tiles will not draw their sprites even though they might be visible (as they can have free positions on them).
2021-01-11
DONE
- Because of the half-baked way prefabs work in scripts, I removed the ability in bloed to edit prefab instances. Users are prompted to either to unpack the instance, or open the prefab editor. Editing the prefab is insanely slow because of a bug in Unity with marking the prefab scene dirty - it removes the physics scene somehow - so I have to save the prefab asset on every change.
2021-01-10
DONE
- I followed the tutorial further and now my ray-casting project has floors and ceilings. Next is either sprites, or collision. Probably both.
2021-01-09
DONE
2021-01-08
SEEN
DONE
- Got very frustrated today, because the prefab workflow with bloed is a never-ending story without a happy ending. After a lot of hair-pulling today I decided to change my approach, with probably as much work as it was before, but maybe a bit less error-prone.
- We did another live-stream today where we played and analysed a stealth game, because that’s what our next game’s genre will be.
2021-01-06
SEEN
2021-01-05
DONE
- Working with prefabs in conjunction with bloed now has much less problems, but it’s very slow and will probably break if the user does anything fancy. Still, it’s better than before. I had to do some nasty hacks because there is a very strange bug with marking the prefab scene dirty and physics.
- I wrote a blog post about my questionnaire from a few weeks ago.
https://ratking.de/blog/2021/01/05/a-questionnaire/
2021-01-03
SEEN
DONE
- By removing a chunk of code (and degrading the performance a bit in the process), I did another step towards usable prefabs with bloed. A big problem currently arises when the user unpacks a Bloxel prefab, which doesn’t recreate the meshes for now.
- After a bit of tinkering - there is no event for unpacking a prefab instance - I can now make the meshes of a BloxelLevel unique as soon as it becomes not connected to a prefab anymore. The same happens when the prefab gets deleted from the project.
2021-01-02
DONE
- I am currently trying to make bloed compatible with Unity’s prefabs, and it’s just hell. There doesn’t seem to be an easy way to accomplish this.
2020-12-31
SEEN
- Ross made a video about SiN, one of the many late 90s era shooters I never played. It is based on the Quake 2 engine and that makes it very interesting regarding level design. The gameplay looks pretty standard. All in all a nice video, as Ross is hilarious as usual.
https://www.youtube.com/watch?v=evvqlj2Kk6Q
2020-12-30
SEEN
- Very interesting and comprehensible video about the Fast Inverse Square Root algorithm (often attributed to John Carmack usually, but as far as I know he’s not the inventor).
https://www.youtube.com/watch?v=p8u_k2LIZyo
2020-12-22
DONE
2020-12-20
DONE
- I recreated the box puzzle game (which was also part of my Unity course) in Flax. I had some fun, but also a lot of bugs and crashes. Some parts of the workflow are okay, most of them are annoying if you’re coming from Unity and are used to it. Right now I wouldn’t recommend switching to it, but maybe observe it for the time being.
https://twitter.com/RatKingsLair/status/1340779890438758401
2020-12-19
SEEN
2020-12-18
SEEN
- Found out about Flax, another game engine that looks very much like Unreal and Unity (via GameFromScratch.com). Somehow it looks promising to me, so I might dig into it a bit deeper in the near future, maybe trying my box puzzle game once again.
https://flaxengine.com/blog/
2020-12-17
SEEN
2020-12-16
SEEN
2020-12-15
DONE
- I had a funky bug today that was caused by Unity’s Unwrapping.GenerateSecondaryUVSet(), as it not only creates lightmap UVs for a mesh, but also optimizes it by potentially reducing the amount of vertices overall. This is a cool sideeffect, but not documented, and messes with bloed’s functionality of updating generated texture coordinates…
- I tried to create prefabs with an instance of a bloxel level - this does not work, at all. There will be a lot of research needed to find out how to make this work.
2020-12-14
SEEN
2020-12-11
DONE
- I did some work on my 7dfps entry, but I don’t think I will be able to finish anything meaningful. Still, it was a good way to get back to networking stuff again, and pulling my hair out over authority and latency and other fun termini.
2020-12-09
SEEN
2020-12-08
DONE
- I laid the groundwork now for a multiplayer-based first-person Sokoban. Not really the best idea I ever had, but it’s something I can do. It also became a gridder, which I didn’t plan to do, but it makes it easier to implement via networking, and it’s so much smoother already than sending transform position updates all the time.
2020-12-05 / 2020-12-06
SEEN
DONE
2020-12-04
SEEN
2020-12-03
PLAN
DONE
- The more or less last step for the texture processor scripts is on its way - making a dedicated tool window that doesn’t need a ScriptableObject. It takes a bit longer than I thought because I don’t want to have too much code duplication, but it seems necessary in this case.
- I gave another course for our students, this time about making a simple dialog system with C# in Unity. Last week it was about doing basic enemy AI. I basically sat down and recorded 1.5 hours of me writing code, while also doing it via a Jitsi server, so people (when there were any) could also aks questions. The next course will probably be about shaders.
2020-12-01
DONE
- Not much to talk about these days. We’re busy with tutoring students, and with trying to find a new direction for our next game project.
Other than that I managed to implement a semi-working solution for auto updating texture processor assets if the source texture changed. It’s probably not the best for performance, but I tried a lot of things and this was the only working way: utilizing void OnPostprocessAllAssets().
https://docs.unity3d.com/ScriptReference/AssetPostprocessor.OnPostprocessAllAssets.html
2020-11-24
PLAN
- 7DFPS is soon, and I’m planning to participate. I would like to use bloed, and the current idea is to make a first-person Sokoban for one or two people. So it would be a good idea to look into Mirror (or another networking solution) once again before it starts.
http://7dayfps.com/
https://mirror-networking.com/
2020-11-23
DONE
2020-11-22
DONE
- Working on a texture processor script for/in Unity currently, and the usual complaint still holds true: serialization of objects is a big hassle.
2020-11-21
PLAN
- It would be nice to have some kind of texture editor (for changing colors and resolution, etc) inside of Unity which does not rely on having special shaders. Maybe I’ll create something like this next, as an add-on for bloed too.
DONE
- As planned I managed to add multi-level editing in bloed, which basically means I don’t necessarily need to have one single bloxel level only in a scene now; it can be several. For that to work in a meaningful way I had to extend all the tools to work with transformed bloxel objects, which was the biggest chunk of work. I also didn’t test it yet with prefabs, which might break it.
https://twitter.com/ratrogue/status/1330165499632754694
2020-11-19
PLAN
- One nice-to-have feature for bloed that I want to tackle next is the possibility to have more than one level in the game. This way it would be easy to create singular architecture, like houses, and duplicate it, move it around, rotate it, maybe even make prefabs.
DONE
- After working a bit more with RealtimeCSG, and not even using every functionality, I must say it is very pleasant to use and definitely feels powerful. Definitely the best tool so far for prototyping levels, and in this case making the final geometry too probably.
2020-11-18
DONE
2020-11-17
SEEN
DONE
- The noisy texture feature for bloed added some complexities that I mostly solved, but probably not completely. For example, changing the texture of cube can change the geometry now, so it’s not enough to only update the UVs. Anyway, I updated the “official” bloed documentation, to version v0.4, and as we’re pondering about using a different level design tool anyway, it might really become a release on itch.io relatively soon.
2020-11-16
SEEN
- I watched some of the Handmade Seattle talks, at least on the first day, and oddly enough, the Unity talk (about DOTS) by Elizabeth Baumel was the most interesting to me, even though it did not really provide much new insights. The talk by Ramón Santamaría (developer of raylib) had a fun concept, but unfortunately I didn’t understand much due to his accent (and me doing other things on the side).
DONE
- Among some other small things I added the ability to have “noisy textures” to bloed. “Noisy” meaning that I can add positional noise to individual bloxel materials. This is still experimental - and very bad for performance if you’re regenerating all meshes at once.
https://twitter.com/RatKingsLair/status/1328269899437907968
2020-11-12
PLAN
- The Handmade Seattle sounds interesting, even though I am much more of a high-level kind of programmer. I was always interested in low-level programming, but I know I will seldom, if ever, use it for a serious project. Anyway, in my time-zone the conference goes from 6pm to 12am.
https://www.handmade-seattle.com/
DONE
- I tested RealtimeCSG a bit - while I’m really not confident with the controls, I can see how powerful it is for quick level prototyping. The documentation is not great (I still keep forgetting how to add Boolean Operations), but in the end the only thing that makes me hesitant to actually use it for our next project (which won’t be Behind Stars) is the fact that there is a new tool by the same developer in the works called Chisel; and apparently they’re working together with the SabreCSG creator. Which means RealtimeCSG will be obsolete sooner or later. I am actually excited for Chisel, but our timing might be a bit off here, again.
https://realtimecsg.com/ - I probably won’t talk about the aforementioned ‘next project’ for a while, just to see if it doesn’t die too early. But overall it means Behind Stars and Under Hills is on ice for the foreseeable future. Again it became too much of a monster, and we were not able to tame it. I might write more about it later.
2020-11-08
SEEN
PLAN
- “Our Machinery”, a new 3D game engine, is out in open beta now for a few days already. I actually applied for the closed beta a few months ago already, but other than downloading it once and having a quick look at it I never really investigated. Maybe someday I will have more time for it - I am still kind of interested in it because you program it in C, which sounds strangely appealing to me, even though it only supports Vulkan and no OpenGL.
https://ourmachinery.com/beta.html - There’s another game jam by the bpb (Bundeszentrale für politische Bildung) announced, online of course, thanks to Corona. I really enjoyed the local events we visited, so I am not sure if I will feel the same with an online event. The theme is “gender” - no idea if I, as the typical cis-man, could create an appealing prototype out of this. So in a sense, it’s an interesting challenge.
https://game-jam.bpb.de/doku.php - I will, at least for a bit, participate in the 11th Clash of Realities. I don’t actually have a deep understanding of what it is, but Professor Jonas Hansen recommended to us and our students to visit it, so here I am, complying.
https://clashofrealities.com/2020/
DONE
- My actual productivity is still pretty low, especially as everything is “in-between” currently. There would be a lot of tasks to do for Behind Stars, but what we actually should do is plan more. Every decision we make feels wrong somehow, which is an awful situation. Of course it could just mean the project is wrong in itself - but then again we never found a good alternative…
It’s also frustrating for me that a lot of my personal projects (Demon Thief, Stealth Gridder, etc) never came out of the prototype state, so I get more and more cautious - maybe too much so.
2020-11-05
PLAN
- Slow progress currently, mostly because of personal life things. But we both downloaded the Unreal Engine with the firm intention to try it out soon, at least for a little bit. Just so we can maybe help our students who choose to use this instead of Unity.
2020-11-03
PLAN
- We’re currently thinking about transforming Behind Stars’ general structure from a full game to several smaller episodes. This way we would be more free in level design and story design.
2020-10-27
DONE
- Although I’m still not convinced that anything I’m doing isn’t nonsense, here is my approach for the immersive sim aspect of Behind Stars: game objects that should react to actions (named Traits in my prototype) need scripts inherited by Attribute (inherited by MonoBehaviour), one for each Trait. There are three semi-different types of Attributes.
The first Attribute type is the general case - every time its Trait is applied, it calls OnAffect() and decides what happens. The simplest example would be “hit” - so every time the thing gets hit its condition worsens, and that’s it. It is also allowed to have Traits that get applied several times over a timespan, let’s say a spell that hurts the enemy for ten seconds, and it loses 1 health point every second.
The second Attribute type is similar, but it doesn’t allow several Traits at once - an example would be a wooden crate that burns: applying more fire Traits won’t give it another “burn” Trait (but it might make the current one stronger).
The third Attribute type is a specialized version of the second one; it allows to differentiate between sub-types of Traits. For example, this can be useful if there is an Attribute that lets an NPC get poisoned by all kinds of poison (snake venom, mushrooms, spells, etc.). So they can be affected by several kinds of poison at once; and even have immunity against certain kinds of poison.
This could all be stupid over-thinking, or the direct opposite - only actually using this system will tell. But what I have to think about soon is some kind of “answer” by the Attribute for Traits, or rather for the Traits’ source. It would be fun to be able to have things like matches, and only if something burnable is touched by it, it gets consumed. On the other hand this is not really how matches work, so maybe thinking about this is not necessary? A better example might be picklocks, they get “used up” as soon as they combine with a door lock, no matter if the picking is successful or not - but they shouldn’t get destroyed if the player combines it with anything without the Lockpickable Attribute. Simplest solution for this would be just telling the Lockpick Trait’s Source object that the action actually commenced, but this feels unclean. - We’re currently doing a “game jam” with our students for the course we’re giving at the Burg Halle. They have to build some kind of atmospheric room, based on a poem by Christian Morgenstern. The results so far are promising - I don’t think I could have created stuff like this back then in university, but then again our tools were much worse, and there wasn’t an asset store...
2020-10-26
PLAN
- After some thinking I will go back to a more or less pure MonoBehaviour based solution for the immersive sim prototype. Because I fear the complexity is increasing even though I wanted the opposite. It just doesn’t make much sense (probably) to fight Unity’s current approach, instead of just using the engine’s features. It would probably be different if I were using the DOTS stuff, but I don’t see me using this in the near future. I should keep looking into it though, otherwise I will definitely become obsolete sooner or later.
2020-10-24
SEEN
DONE
- I did some prototype code for Behind Stars’ immersive sim aspect, and while I am sure this is not how you should do it, so far I like my solution. I am just not sure yet it will be applicable for all the needed use cases. And if the performance will be good enough when there are hundreds or thousands of objects.
2020-10-22
PLAN
- I am currently doing thought experiments about Behind Stars and Under Hills, especially about the immersive sim aspect. On the surface it sounds easy enough: make a system where (potentially) every object can react to (potentially) any action. As usual the devil is in the detail, and in the implementation. Checking every type of object against every type of action is madness of course, so I have to find something that is less verbose. I’m definitely not the greatest programmer, and stuff like this makes it more obvious to me.
2020-10-21
SEEN
- I can really imagine myself making a very small game with this. I like the idea of PICO-8, but I actually dislike the resolution of the programming window, so this might be more up my alley.
https://microstudio.dev/
2020-10-20
SEEN
2020-10-18
DONE
- As part of the Halle of Games festival I showcased It Rains. I also participated there in a 2 hour workshop about making board games, which was pretty cool - the coach was a fellow game dev who did board games and mobile games before. In any case, this was a very long but eventful weekend, because we were at the festival the whole time.
And while keeping children from destroying the computers and explaining the games to some of the visitors and also while helping out with various stuff (carrying chairs, getting pizza, installing software, etc.), I managed to re-program my Arduino-based “game pads” I created for last year’s summer showcase of the Designhaus. Those game controllers were part of a game I called Richtig Gute Buttons (it was never really good, though), but I took them with me and repurposed them with a simple game where you have to tap the right button at the right time. While I finished much too late and pretty much nobody played the result, it was still fun to fiddle around during the exhibition.
https://halleofgames.de/
By the way, I had a hard time getting my old C++ code for RGB to run on the Arduinos - until I discovered that they’re Leonardo clones, and I tried to target Uno boards. Dumb me.
2020-10-16
DONE
- While still not sure what Tree Defense, now officially called It Rains, actually is, I uploaded it to itch.io and called it a day. I like the overall feeling the “game” has though.
https://ratrogue.itch.io/it-rains
2020-10-14
SEEN
DONE
- I finally updated the “official” version of bloed by extracting all the changes I did in Demon Thief and calling it v0.3. I even updated the documentation accordingly. I’m entertaining the thought of putting it on itch.io for two or three dollars, just to have it “out there”.
- For Tree Defense I dug a bit deeper into Heaps these days, because I wanted to know if I can dynamically change the vertex colors. It’s unfortunately not that easy. I also noticed a graphical glitch - for every mesh with vertex colors the last vertex would be black, no matter what color I assigned to it. In the end I submitted a bug report, because I couldn’t find the error in my own code.
https://github.com/HeapsIO/heaps/issues/896
It doesn’t matter anymore anyhow, because I switched from vertex colors to a shader that would take an additional texture which I can actually change on the fly during the game. The current result is promising, and it looks nice. The game is becoming a simple “simulator” more and more. - So far I did #inktober nearly every day, even though I hate everything I drew, so maybe I’ll stop the next few days.
2020-10-12
DONE
- Today I worked on Tree Defense, doing things I didn’t plan to do. But I added a compass that shows the current wind direction, because I plan to change the player’s actions from planting trees to creating clouds. The clouds will rain, and follow the wind direction. The player's task is to water the trees with the clouds and help them to grow this way, basically playing “as the weather”.
2020-10-11
DONE
- Commissioned by Jana, for the Silbersalz Festival I created a small program that would take a text string and directly convert it to a series of character codes (in binary). I used heaps’ Input Example as the basis for that. The interesting part was that it currently runs on a Raspberry Pi and while I hoped I could run the program via Hashlink, this didn’t actually work because Hashlink doesn’t support ARM devices. (Which I didn’t know before.) And I just couldn’t get the C code to compile on the Pi. In the end I just made it a HTML5 application, and it works okay-ish, even though it is prone to users pressing Escape or Alt+F4.
https://heaps.io/samples/input.html
If I were to do this again I would probably use Raylib. Raylib can even run natively on Raspberries, but not on the new one (4) because of some changes. But the desktop version would have been okay too. Update: seems this was actually fixed yesterday, with the DRM platform target.
https://www.raylib.com/
2020-10-08
DONE
- The trees in Tree Defense can die now - either by too much water, or not enough water. Before that I implemented the time concept, so everything is “automated” now, although nothing is balanced in any way. Adding some kind of weather is the next step.
- I made it possible in Demon Thief that interactive things (loot, buttons, doors, etc.) can take time before they actually get active. So the player has to press the mouse button a bit longer before it does something, and if they cancel the action - either by releasing the button or by unfocusing the object - it won’t do anything at all. This is something most games do nowadays, mostly because it adds a bit of “investment” for the player, and because you can make an action more meaningful by changing the interaction time needed. And third you can have more than one action associated for the object by distinguishing between short and long interaction - for example, in Gloomwood you open a door by clicking it, but if you keep the button pressed a bit longer, you open it slowly (and thus make less noise, which is always good in stealth games).
2020-10-06
DONE
- For Tree Defense I did some things which unfortunately are not to be seen in screenshots. But at least now I can remove water from a tile/lake, and the camera controls were improved too. There’s also info visible if the player hovers a tile.
For the near future I want to add the concept of time - trees should grow by themselves (instead of me clicking on them) and use water from the tiles; water should evaporate over time, and it should rain now and then. The latter will be the “Tower Defense” part, where the amount of rain will get worse in the later game, and the amount of sunlight too much. - I wanted to make a simple “level plan” for Behind Stars and Under Hills. While I could just use pen and paper, I actually needed something that lets me make the three-dimensional structure of the caves and dungeons much more clear. At first I tried Blender and later a tool named Tinkercad by Autodesk, but then I settled by just using Unity - together with Clayxels. This way I can create more “organic” caves, instead of just simple boxes, and stick them together.
https://www.tinkercad.com
2020-10-03
DONE
2020-10-02
DONE
- Demon Thief now has doors, at least conceptually. It seems editing the graph (the navmesh the AI agents are walking on) can be done easily, for example with tags; and these tags can be used to prevent AI from walking there, or not, and let them have the “key” (tag) to walk there. The biggest thing missing is the actual door graphics to make it look good.
2020-10-01
DONE
- Small steps for Tree Defense: tiles can now “save” water, so they will actually be useful for the trees that I can place on each one.
- Small steps for Demon Thief: I improved the sword animation (this is an ongoing story), and added animations to the bow of the player. I also added some of the assets from the fantasy packs. Only by reducing the texture sizes they’re now actually usable for me.
- Small steps for Behind Stars and Under Hills: I wrote down the complete main quest in Miro, and now - together with what Jana wrote - it’s a good basis to discuss it and change it.
2020-09-30
DONE
- For Tree Defense I tried to find some cheap low-poly trees so I can place them on my blocky terrain. This proved to be somewhat more work than expected, because as usual “free”, “clean”, “good-looking” and “easy to get” seem to exclude each other most of the time. In the end I decided to use an asset that I got from the Unity asset store by Broken Vector.
https://assetstore.unity.com/packages/3d/vegetation/trees/low-poly-tree-pack-57866 - We continued working on Behind Stars’ quest line - even writing down only the main quest makes it look like an entangled mess; but that might not be bad in itself. But overall we noticed we need to focus more on our core points (secrets!), somehow they get lost while writing a story.
2020-09-29
SEEN
- My brother visited us over the weekend, and among other things we played a short session with my newly acquired Story Cubes. While our attempts at spontaneous story weaving were laughable at best, it actually sparked a bit of hope in me that such “random inspiration” could be used for creating quest lines for Behind Stars.
https://www.storycubes.com/ - I skimmed over this water shader tutorial, it’s basic and still complex enough to learn something from it. The rippling effect was the most interesting, I wouldn’t have guessed it’s just a particle effect combined with a second camera for RTT.
https://halisavakis.com/my-take-on-shaders-stylized-water-shader/
PLAN
- For Zauberwald, the text-adventure, my brothers and I discussed a bit if it would make sense to have characters that could roam through the different screens. Ultimately I decided that would be too much work and probably not that much fun anyway. Instead I want to have the characters working like other objects you can click and look at, but with a bit more interactivity for a ‘dialog’ with them.
- The application for our course for MM|VR is now online, so students can apply until October the 6th.
https://www.burg-halle.de/design/multimediavr-design/multimediavr-design/lehrangebote/l/play-your-self/
DONE
- I got my “water flow” algorithm for Tree Defense working, in Heaps. No idea yet if I will actually make a game that works, but it was an interesting experiment. I will try to do one thing per day, to minimize the workload, and keep the project interesting for me. If I see enough potential shortly before the deadline in 17 days, I might try to expand it to a usable experience.
https://itch.io/jam/climate-change-trial-and-error - We worked on Behind Stars’ story a bit, especially by re-telling it. It feels like it might come together nicely, but of course at least 80% is still missing. The next few days I want to just try to create quests and maybe tie the game’s plot together this way. I would be using Miro for that, as we already do all the planning in it.
https://miro.com/ - Even though I am a bit demotivated when it comes to Demon Thief, because it won’t be finished anyway, I am still working on it from time to time - for example, I added a bit of furniture from some Fantasy asset packs. I also like how the Thief-likeness is actually a plus for a lot of people, so I am still downloading a lot of photo textures from textures.com.
https://twitter.com/RatKingsLair/status/1308717663984799745
https://twitter.com/RatKingsLair/status/1310556209594929153
The Demon Thief project might be useful though as a test-bed for things we want to do in Behind Stars. E.g., I wonder if the system for the immersive sim mechanics actually work.
2020-09-25
DONE
- Not much was done this week, but at least I fixed a strange, obscure bug that appeared in my bloxels; apparently my calculation for the UVs of bloxels with more than 2 sub-textures was wrong, but only if the “direction” was 1 (“rotation” didn’t matter). In the end it was just commenting out one line of code, but until I got there, that needed some serious code digging.
- I think I figured out an algorithm for distributing water in Tree Defense, but currently I am not really in the mood to actually implement it.
- I took Jana’s chart for the “immersive sim” gameplay of Behind Stars and Under Hills and extended and transformed it so it feels more like the blueprint for an actual game system. Objects in the game, either characters, 3d objects (e.g. furniture) or items, would be called Things, and Things can have Traits - which means you can, for example, give anything the “poison trait”, but only characters would actually react to it. On the other hand a lot more things would react to the “damage trait” - characters lose health, doors and chests get destroyed, items might disintegrate.
2020-09-22
DONE
- The player has a much better sword now in Demon Thief, but functionally it still has a lot of problems. For example, it doesn’t work correctly when the player is crouching, because then the sword moves into the ground... Also the enemy reacts more “rationally” now when they get hit by the player’s sword, as they’re instantly turning to the attacker.
Overall I’m currently thinking about stopping the project - not because I don’t like it (the opposite is true), but because it feels like wasted time that I should spend elsewhere. Namely: Behind Stars and Under Hills.
Nonetheless I finally chose some textures for the level I’m working on and placing them here and there. Even though the level is missing everything (lighting, props, enemies), it already looks much more “real” now.
https://twitter.com/RatKingsLair/status/1308489050769305600 - For the Climate Change Jam game I want to do, with the working title Tree Defense now, I started a Heaps project and generated a mesh for the ground via h3d.prim.Polygon. Currently I’m thinking about how to actually make the “rain logic”, i.e. how water will be distributed over the different tiles and their neighbours; it’s more complex than I anticipated.
2020-09-19
SEEN
DONE
- I am now more confident with the solution of melee attack of the player in Demon Thief. It’s a far cry from my personal gold standard Thief (I won’t even try to think of Dark Messiah, it’s too advanced for my aspirations), but already works okay-ish. Of course the animations are terrible, and don’t feel good yet, but at least they’re animations I can do in Unity.
- Some more small improvements to bloed - it uses a GUISkin now, so I can change the look much more comfortably. Also, as this was always a step I had to do manually, textures to be used for the bloxels are now automatically changed so they’re a) readable from scripts, and b) uncompressed.
2020-09-17
DONE
- While I should work on the level(s) for Demon Thief, I actually do a lot of small things on the side, mostly beneficial for bloed. For example, the joists are much more integrated now, the hover marker and cursor work and look better, and the editor got some more colours. I guess there is a reason why I’m putting the important work off, and the reason might be that I know that Demon Thief won’t be finished in the two months anyway.
2020-09-15
SEEN
DONE
- A bug appeared in Demon Thief that was hard to track. It seems I made a change to the enemy’s code at some point in the past that broke the flee behaviour (and probably more). The problem is that for over a week I didn’t check if the fleeing was still working (because I didn’t suspect it wouldn’t), and now the enemy just wouldn’t run away after getting back to their start position. Thankfully, git made it easy to try out older versions of my project, and after a while I found the culprit - something bad happens when you set the destination of the RichAI component to Infinity. Which I thought would be the way to let the path-finding AI stop.
Turns out this is true, but when you use richAI.destination once, you have to use it always - you can’t just use StartPath() and then be done with it. So I have to manually set the destination to the last point of the path; which smells like a bug to me.
2020-09-14
DONE
- The sword-wielding enemy of Demon Thief had the small but annoying problem that they wouldn’t be able to hit the player if they’re standing on stairs, because even with the Look Animator the slash animation is vertically too limited to reach the player’s hit box. I circumvent the problem by moving the sword’s hit box up and down, into the direction of the player. This is very hacky, but at least it works.
2020-09-13
DONE
- While I’m busy every day downloading textures from textures.com, because I am actually building a somewhat larger level for Demon Thief nowadays, I also added the BloxelJoist tool to bloed. First I had it as a parallel tool to the bloxels, but then I decided to make it a subtool just like the Texer or the Cuboider. It works quite fine this way.
What I noticed is that the levels get quite large, and I have to be careful not to upload the gigantic meshes to git. I can remove them before I do that, so that’s what I do.
2020-09-09
SEEN
DONE
- Tried to build a small room for Demon Thief with bloed. Made a video of the “result” so far. In other news I bought 2,500 credits on textures.com, so I can download all the low-rez textures I need for this game, without having to wait days (you only get 15 credits per day, and those are only usable for that day).
https://twitter.com/RatKingsLair/status/1303774533640388608.
2020-09-08
DONE
- I ported the joist tool from Behind Stars to bloed, but it’s not done yet. Especially as there are some hurdles with duplicating a joist and actually deep-copy a mesh. No idea yet how to do it.
- After some trial and mostly error I just name the mesh the same as the instance ID of the game object - if it’s different, it instantiates a new mesh. A bit hacky, but it works well enough.
- It would be cool if the joists are actually part of bloed, so you can create them with one click (instead of having to create an empty game object and add a BloxelJoist component manually).
2020-09-07
SEEN
PLAN
- For the upcoming Climate Change Jam for the Silbersalz Festival I’m planning to make a small game in the vein of a Tower Defense. My biggest problem right now is to find the right tech, because once again I would like to deviate from Unity - so far the options are Heaps and Godot. Heaps would be interesting, because I’d like the game to be 3D and I never made a 3D game in Heaps, but that also means I would need more time for the development-
DONE
- For a change I worked on bloed again - because I needed something for Demon Thief. I added the ability to have different standard bloxels and different methods to set them. This way I can, for example, create a floor automatically, and for the first level I want to make this means I will need less bloxel data (probably), reducing the level’s memory hunger.
2020-09-06
SEEN
DONE
- Fiddled a lot with the settings for the ragdolls in Demon Thief today, but there are still a lot of edge cases where they are wonky, wobbly or just plain crazy. Physics in computer games is the bane of my existence.
Thankfully, making the archer skeleton a bit more aware if there’s a companion in front of them or not (and thus not shooting them in the back) was less work than I feared. Of course friendly fire still happens a lot, but that’s actually okay. If it happens too much I can make enemies just immune to it.
The third thing today was refactoring the UI a bit so it works as a separate scene. This way I can test levels more easily; and eventually I will have to separate all the game logic too.
2020-09-05
SEEN
- I have the API help for EditorTool still in my bookmarks because I will definitely use it at some point, but so far I didn’t get around it. No idea if there’s a big advantage over the old method of creating editor tools, other than having a neat icon in the scene view.
https://docs.unity3d.com/2019.3/Documentation/ScriptReference/EditorTools.EditorTool.html - Insight of the day: raycastHit.transform is not necessarily the same as raycastHit.collider.transform.
DONE
- I finally created my first ragdolls and added them to the enemy of Demon Thief. Fortunately there are automatic tools for this nowadays, so it didn’t take long to prepare the model. The only “problem” was that I forgot to deactivate the LookAnimation component, so the ragdoll would behave like crazy. I also noticed that the best approach for my enemy’s death is that I only activate the ragdolls in the middle of the death animation. I always dislike it when characters have no dedicated death animation and just get to being ragdolls instantly, which makes them look like unimmersive puppets. And I can’t activate the ragdoll at the very end of the death animation, because that often clips the model into the wall and would lead to glitches.
2020-09-04
DONE
- Apart from a tiny bit for Demon Thief, the biggest achievement today was that we discussed Behind Stars’ story and quests more. In my opinion it makes sense, is not too psychological and a good foundation to build on. Of course it is very trope-y, which I would love to improve, but on the other hand we’re already alienating people enough by having characters with animal heads. So more familiarity is probably a good thing.
I also created a mindmap (on a Miro board) for the gameplay, and it’s a mess. But somehow everything is “important”. The next thing now is to prioritize (although we already identified the core gameplay), and simplify. The amount of gameplay elements will probably not decrease, but with every element we will have to think hard about how to implement it in the simplest way possible. For example, pausing the world in a dialog is good, because you won’t have to deal with strange AI problems. And with a simple screen fade you don’t have to check if the character is standing at the correct point to talk to you. And so on.
2020-09-03
SEEN
DONE
- Demon Thief, yet again. I worked a bit on the inventory of the player. As most things in my prototype it’s inspired by Thief, where it definitely existed, but was very simplistic and a bit hard to use. (The latter I will try to do better - mostly by reducing the amount of items available...) I also added the usual highlighting system (already in use in Behind Stars), to improve the visuals when hovering an interactive object.
- A while ago my brothers and I hatched a plan to create a text adventure, inspired by an old C64 game we played as kids. For this project, code-named Zauberwald (after that text adventure), I now made a prototype in Twine. This was actually interesting, because I tried to create an inventory and object system with Twine’s Harlowe macro system, and it was kind of doable.
2020-09-02
DONE
- Enemy AI, day 1986342. The archer enemy in Demon Thief can now shoot up and down, depending on where the player stands. I was too lazy to actually find out how to calculate the trajectory from the point of impact, so I searched in the Unity forum and found a thread with code that did what I wanted. Finding out why it didn’t work out of the box and fixing it took quite some time though.
https://forum.unity.com/threads/trajectory-calculations.98598/
I also added a second enemy skeleton for the first time. I always expected it to go totally haywire, which is why I delayed this step. In any case I found an animation bug this way, and it made me think about how to prevent an archer from shooting another enemy just because they’re in the way…
For the enemies to look into the direction of the player in a “natural” way I bought an asset called Look Animator. It produces strange results so far, so I have to tweak it a lot more I guess. It also created problems with a script of mine that makes a GameObject following another - this doesn’t work anymore in a specific case because the Look Animator moves the object further after I moved it with my script. Oh well, maybe I’ll look into that too.
https://assetstore.unity.com/packages/tools/animation/look-animator-122249
2020-08-31
DONE
- Made a video of the far range combat behaviour in Demon Thief, and the flee behaviour.
https://ratrogue.tumblr.com/post/627968199816773632
Furthermore I (hopefully) improved the “suspicion” behaviour the enemy. One of the problems was the reaction of the enemies for when they were hit by the player’s arrow. Enemies should search for the player when that happens, but not directly run at the player. The reaction should be different if the enemy is already inspecting something suspicious. And so on. As usual, it’s a fractal of a problem area, and it only gets more detailed the more you look at it, but never really solved.
2020-08-30
SEEN
DONE
- As planned I extended Demon Thief’s enemy’s behaviour so it supports ranged combat. It was a bit tricky because I want to have both enemies that can switch between ranged combat and melee combat, and enemies that only have a ranged weapon. So the latters have to “flee” as soon as the player approaches them, and find a spot to attack the player from a safe distance. Later on I even want melee fighters that only use some simple far range weapon (like stones picked from the ground) when the player is not reachable. But that’s for the future.
I also added the “quest” system. Because of the possible dependencies between single quests it took longer than I thought. Next up: better behaviour when the enemies gets hit without them knowing about the player yet, better death handling (not sure I want ragdolls though), some limitations for the player’s arrows, the enemies being able to shoot up and down. And while the AI will probably never be finished I really should look more into the visual design aspects of the game, not later than the week after next. - We’re doing more and more planning for Behind Stars, and we now have a very, very rough story, and some fractions that should be part of it. Overall I’m confident we can write some interesting/fun characters with it.
2020-08-27
DONE
- Demon Thief. The enemy’s behaviour tree now has flee behaviour, which is a lot of fun. Because whenever their health is low they run away to a randomly chosen point, and after a while come back. But when they see the player again (or just hear a suspicious “sound”), they run away again. I also added the ‘getting hurt’ animations, which really brings it to life, and the player now gets visual feedback whenever they’re hit.
Next I want to add ranged combat for the NPC. To take a break from the AI I will also add some kind of mission progress soon, so the player gets tasks in the beginning (“steal 500 gold”, “kill this enemy”, “don’t get seen”) which get ticked or crossed off during the game. When they fulfill all tasks, the mission ends. (Note to myself: to have a task that forces the player to return to a certain place to end the mission, I need to have tasks that are dependent on other tasks. And in order to not confuse the behaviour tree tasks with mission tasks, I will call them quests.)
2020-08-25
DONE
2020-08-24
SEEN
DONE
- I gave the enemy “AI” in Demon Thief some “suspicion” value, and whenever this value raises (e.g. by a sound caused by the player), the enemy walks towards the suspicious target point. When they reach it, they choose another point randomly near this point, to look a bit further. This is all a bit wonky still, but a good start.
My biggest problem with behaviour trees right now is that they are kind of stateless, so I have to find a way to reset values when the character switches from Patrol to Inspect behaviour and vice-versa. So far I added an Initialize(string) task that instantly returns when the parameter is the same as last time it was called. Otherwise it resets some values, depending on the state that was set - which probably is not what one should do in behaviour trees, because it’s by design not a FSM.
2020-08-23
SEEN
DONE
- I compiled a test Unity project to WebGL just to check the generated C++ code, because the discussion with Felix about if (gameObject) and if (gameObject != null) left me wondering. And lo and behold, the generated C++ code is pretty much the same - the first line of code actually becomes Object_op_Implicit(gameObject), which itself calls Object_CompareBaseObjects(param1, NULL). And the second one becomes Object_op_Inequality(gameObject, NULL), which in itself calls Object_CompareBaseObjects(param1, param2). So I guess the first version is a tiny bit better, because one less parameter is used. But Felix actually claimed the first version would catch more null errors, which I can’t believe right now; maybe the result is different when Mono is used as back-end instead of IL2CPP, but I doubt it somehow. Only real-life bugs will tell.
2020-08-22
SEEN
- Had a discussion today about how Unity’s Objects and their weird behaviour regarding null can be confusing. I stumbled over this today because I tried to check in some method in a generic class if a generic parameter is null, and forgot that a UnityEngine.Object can be null and not null at the same time, so I had a (thankfully small) bug. After that I discussed with Felix about the differences between if (gameObject != null) and if (gameObject) to check if a game object exists - it’s interesting to me because I always used the former. I read about the whole matter ages ago and what I took away from it is that both forms are okay, but the first one always felt more explicit to me and easier to “read”. But Felix said the second form should be preferred because otherwise it leads to bugs (“it explodes”) in edge cases like level reloads. I need to test this next time I encounter such a bug.
2020-08-21
DONE
- I implemented some very rudimentary “bow” mechanic in Demon Thief, just to switch to a different task while I still mess with the AI, extending it and fixing bugs on the way. The suspicion level should be the next addition, but also some flee behaviour, because it would be strange for the enemy to stand around dumbfounded while they’re hit by arrows.
2020-08-20
DONE
- I’m still occupied with the “AI” of the enemies in Demon Thief, and I am sure I will be for quite a while. At least the test-skeleton now sees the player and immediately follows them - later on there should be a “suspicion level” of course, and different movement speed for patrolling and following. In any case I enjoy PandaBT a lot more than NodeCanvas so I bought the Pro version. Even though the developer of PandaBT doesn’t seem to be active anymore, at least that’s the word on the official Unity thread. Thankfully the Pro version has the full source code, and some people are still active in the forum.
- We tried to give the possible gameplay elements of Behind Stars different priorities, but in the end we couldn’t really decide. It always comes back to the fact that we somehow want to have everything, but mostly: talking to NPCs, running around, finding secrets. A bit of alchemy would be cool too. Oh, and of course some challenging combat. And so on.
This is why we need to create some scenes to test the style, and several prototypes for the different aspects of the game. We played through the last iteration of the game to check out what we would change, but mostly we were like “that’s so cool, let’s keep it”...
But, on the bright side, even if Demon Thief won’t be a success (in terms of “getting finished”), it definitely can already serve as a pre-version of the new Behind Stars, because implementing the AI/combat is beneficial already. It doesn’t have to be innovative, it has to be fun. In my opinion we should concentrate on the aspects “secrets” and “alchemy” for the innovation - I’ll think about it.
2020-08-18
DONE
- Created some simple patrol path editor for the Enemy class in Demon Thief, and now the skeleton follows pre-defined patrol points. I am slower with this project than anticipated, but it’s still fun somehow. Next up: enemies should sense the player. It would also be cool if I could define wait times at each path point, to make the patrol behaviour a bit more interesting.
2020-08-17
DONE
- Today was the “official” start of my 2 month project Demon Thief. Currently I’m mostly occupied with creating enemies, because they will be one of the most important aspects. I have the websites/documentations open for Animancer Pro, A* Pathfinding Project Pro and Panda BT (Free), switching between them all the time. Panda BT is now what I plan to use for the behaviour trees of the enemies - reading the documentation was a breeze, and it looks like it should be powerful enough for my needs.
- We created a time schedule for our next projects (mostly our personal projects, Behind Stars and Under Hills, and teaching at the Burg Halle next semester), and the rest of 2020 looks pretty stressful…
2020-08-14
SEEN
- A user at the A* Pathfinding Project forum told the developer that they found another pathfinding asset and they’re happier with it. I was curious so I wrote them, and they recommended Super Pathfinding System. As I still have my problems with A*PPPro I will have a look at this.
https://assetstore.unity.com/packages/tools/ai/super-pathfinding-system-168018
Update: Looks a bit too simple for my needs. The example video/screenshots also show some errors in the path...
PLAN
- From next week on I will “officially” work on my 2 month project (working title “Demon Thief” for now). It will be a Thief-like made with Unity. I plan to use the following assets, but nothing is set in stone:
- Bloed - my own level editor. It’s not really finished yet, but should be usable enough for this kind of project.
- Rewired - a very powerful input system that makes it much easier to support gamepads; a must nowadays.
- Animancer Pro - for easy animating the characters without having to annoy myself with Unity’s Mecanim.
- A* Pathfinding Project Pro - for letting characters walk around in the levels. I’m not really sure about that one yet (see earlier log entries, and the SEEN above), so I might have a look at other assets before I start. It seems to work though as long as I don’t try too complicated stuff, and as long as I don’t need support on the forum. The character being able to reach the player without getting stuck is the essential thing. (Note to self: use breadcrumbs maybe?)
- NodeCanvas - for the “AI” / behaviour trees of the enemies. I haven't really used this for a few years now, I think last time it was for our 2D co-op prototype Power of Love, and I wasn’t happy with it. Maybe because I was using it wrong, but mostly because it felt like overkill. So it could be that I will just use MonsterLove FSM (on github) which I actually already use for my Utility Theory AI system (I could use that one too, but I don’t think it would be a good idea with this project, as the enemies are not needed to be emergent and human-like). In any case I just want to do simple BTs instead of trying to be too fancy with AI. Another asset I could try in this regard is Panda BT Pro.
- LeanTween - probably for tweening, but I might have a look at DOTween Pro’s capabilities again. Maybe my own naive implementation (RatKing.Base.Tweens) is enough though.
- More Effective Coroutines - I import it often in my projects, but I might actually omit it this time, because I mostly use the functionality of delaying function calls, and that one is also handled in my RatKing.Base.Tweens class. Probably not as effective though.
- Rainbow Hierarchy 2 / Rainbow Folders 2 - because they make the project much neater, and a little bit easier to handle.
- QHierarchy - just to have extra buttons for hiding/showing game objects right next to them in the Hierarchy window. Can’t live without it.
- Console Enhanced Pro - not that much needed anymore as Unity’s standard console window has improved a lot since I purchased it, but it still has a few advantages.
- Several fantasy 3D model assets, because this will be an asset flip...well, they were on sale during the “Discounts&Dragons” sale on the Unity Asset Store, and I know that I won’t have time to do all the models myself. So I don’t see shame in trying to save some time. I also don’t expect to win a design award for this game.
Other assets that might be interesting for this project are: Mtree, UMotion Pro, Volumetric Fog & Mist, Wire Builder, Search Grid, Odin, VertPaint, Bakery (for light maps), MK Glow, Mesh Combine Studio 2, Puppet3D (for rigging), Final IK, Easy Decal, Amplify Shader Editor, Amplify Color, Highlighting System or Selected Effect, Hx Volumetric Lighting, GraphIt, Colorful FX; and maybe something for gameplay scripting (MiniScript).
DONE
- Did an A4 page of nude drawings and even after a day I don’t really hate it. Either I’m getting ignorant towards my shortcomings or I really should draw more again.
2020-08-10
DONE
- After some more tests with A* Pathfinding Project Pro I am still not sure if it has been improved significantly. Seemingly simple problems like just letting the AI Controller follow the path while always looking into the right direction turn out to be a hassle already. Meh.
2020-08-09
DONE
- During vacation I prepared a bit of the groundwork for my 2 month project. I want it to be a stealth game in the vein of Thief, so I took bloed, the character controller of the Behind Stars prototype, and the light gem functionality of the ping-pong project and combined them. So far so “good” - a lot of tweaking is necessary of course, and the most important thing (the AI) has to be prepared sooner rather than later.
- For the upcoming projects I bought a Unity asset called Bakery. It’s a much better alternative to Unity’s own lightmapping stuff, and it already was much faster both in terms of usability and in plain lightmap baking. I will do some more tests if it actually is a good tool to use for the 2 month project and for Behind Stars, because of course I need a combination of dynamic lighting and static lightmaps.
- Another asset I bought is the A* Pathfinding Project Pro (I still dislike the name). We actually used this before, mostly for Solitune, but since then new versions came out which meant we had to buy the upgrade. I hope the asset was improved a lot, as I had problems when I incorporated it in Solitune - strange behaviour of the character controller and so on. But it’s one of the most popular assets on the Asset Store, so my guess is that I just have to dig deeper this time. In any case, I do hope it will be helpful with the 2 month project, because I don’t want to put too much work into things that are solved already.
2020-08-04
SEEN
DONE
- I am creating yet another “music video” for one of my brother’s tracks (as usual with HitFilm Pro), for Behind Stars this time. It’s a bit bitter-sweet, because it makes me going back to the prototype, specifically the (very old) “Outpost” level, and capturing some scenes.
2020-07-29
SEEN
- Currently reading the Arduino Kompendium by Danny Schreiter. Even though this is beginner stuff which I already know, there are still new things I didn’t know (which shows that I didn’t too much with my Arduinos yet). So books like this help me to get back to electronics, which interest me but will be obscure to me forever and for which I apparently never have a real project. The latter is the reason why I never learn something “properly”.
2020-07-27
SEEN
DONE
- I uploaded version 0.2 of bloed, so if there will be someone testing it some day, they will now have to have both project settings and individual level settings. The updated documentation describes it in detail.
2020-07-26
SEEN
- As usual, small things can be more complicated than you’d think initially - like calculating the field of view in a grid-based roguelike. This algorithm is pretty sound. I wonder how easy it would be to have both diamond-shaped and box-shaped walls in it.
https://www.albertford.com/shadowcasting/ - Nicely done article about light and shadow by Bartosz Ciechanowski, as it visualized the math behind it pretty well - and you can interact with it!
https://ciechanow.ski/lights-and-shadows/ - Pretty voxels (blocky and not-blocky) for Godot - unfortunately this “plugin” must be compiled into the engine, so I will probably try it much later only.
https://github.com/Zylann/godot_voxel
DONE
- For bloed I did the first steps to be able to have different settings for different scenes. Which means one scene can have boxes as standard template (so you dig into the level) while another scene would have air as standard (so you build the level from nothing). The only problem remaining for this is that I put all the standard templates and textures, and the lists of templates and textures, into the BloxelSettings, and those should actually be saved globally.
In the future it would be interesting though to be able to have different sets of textures for different levels, so you plan the size of the texture atlases better. (This wouldn’t make as much sense for the templates.)
2020-07-25
SEEN
2020-07-24
SEEN
2020-07-23
SEEN
- As I subscribed to Jackson Dunstan’s blog I also read his series about C++ for C# programmers. It’s still interesting even though I know a bit of C++ (I used it a lot in university actually, in combination with Irrlicht and OGRE, but I never was really proficient in the finer details of the language.) The thing is that you learn something new about C# too, and I found the article about references particularly worthy of a bookmark.
https://jacksondunstan.com/articles/5587 - Unity made the visual scripting asset Bolt free today, as they acquired it a few months back. I might have a look at it, just because it could be fun to use it, and maybe even teach it. A successor is also announced, and it probably won’t be fully backwards compatible. So I’m not in a hurry to try it out, but the option is still nice.
https://assetstore.unity.com/packages/tools/visual-scripting/bolt-163802?aid=1011l4rAy - This looks interesting - DREAMUV, which also includes an automatic UV unwrapper. I did think it looks like it would be straight out of Valve’s Hammer, and then I saw the creator is actually a Valve employee. It’s cool that they use Blender too.
https://twitter.com/Leukbaars/status/1279288819708125185 - Unity 2020.1 is finally out, and there seem to be one or two features of interest to me. But overall it feels meh more and more. Which is probably because I will never be an AAA developer.
https://blogs.unity3d.com/2020/07/23/unity-2020-1-is-now-available
2020-07-22
DONE
- The Coxel-like is now done (not really, but the main functionality is there), and even after all the problems I had I actually think I will try to use Godot some more. I still find the whole node system somewhat unnatural for me though. Being able to use C# made the engine much more approachable to me, especially as I had a look at my old GDScript code in other projects and didn’t understand much anymore.
2020-07-21
DONE
- More Godot woes are coming, as I’m still trying to port my Coxel-like to it. nuget restore helped to remove the annoying dialog in VS Code that told me on every start to restore the project - I tried dotnet restore, but that was obviously the wrong choice.
Now I have to battle with the fact that I got the problem again where the project would only build but not play whenever I press F5. It does work if I start it from VS Code though, so it’s only 50% awful.
2020-07-18
SEEN
DONE
- I “optimized” bloed a bit by removing the list of strings for saving the unique IDs of all the templates and textures, and replacing it with lists of indices which would refer to lists of the IDs inside the BloxelLevel script. In certain cases this might be even bigger, but most of the time it should remove a bit of superfluous data.
2020-07-11
DONE
- I created a documentation for bloed, so I (theoretically) can give it out to people who are not me. Not sure what kind of feedback I expect though.
2020-07-10
SEEN
PLAN
2020-07-09
PLAN
- With bloed being not finished but at least mostly usable now, it might be a good idea to make a little prototype game with it, maybe a shooter or a simple adventure game. For Behind Stars I’d like to make a combat prototype that should be very quick to create (at least that’s the goal) and still be interesting and challenging. The bloxels would be a good way to test the terrain for that.
2020-07-05
DONE
- Bloed is consuming most of my free time nowadays, because it’s the most rewarding hobby project I have currently. So since my last entry I added a copy&paste tool (not finished yet) which lets the user rotate the copied bloxels even - this wasn’t possible with the Copy&Paster in the Behind Stars editor Morited. It does not copy extra side data for now.
I also tried to add round corners as bloxels - they produced problems with the UV generation, and while I mostly fixed it somehow, they made it apparent that the Texer tool needs an additional option to set the offset of bloxel sides. Because otherwise there will be visible seams much too often.
2020-06-30
PLAN
- I’m thinking about the “2 month project” I want to do after we are finished with the contract work that is currently occupying us. Two months because this is the time we needed to to publish Pitman on iOS back then - the game itself was done in the first 7DRL Challenge we ever participated in, so this is a good point of reference. This means I will try to implement the game in one to two weeks, the rest is polishing, testing, bugfixing. Overall I’m looking for a very small project that still might be commercially interesting (probably donations-only though, or there’s a version with soundtrack that you have to pay for). Other than that I’m mostly hovering over ideas that are too big for now.
DONE
- I added the (player) character controller I wrote for Behind Stars and Under Hills to the bloed project. It was actually kind of manageable, but there are two rather big dependencies that I’d like to remove: LeanTween (for the camera shake stuff) and Rewired (everything input). The first I maybe can implement myself, and for the second I might just create a wrapper, although I dislike having too many layers.
Of course I need to remove the controller should I ever make bloed’s code public, as it’s not needed and bloats the project too much.
2020-06-28
SEEN
DONE
- I’m still working on bloed from time to time, and it’s still all about re-implementing the things the old Behind Stars level editor had. I can be a bit more flexible now, and have some features faster, which is great. Currently it’s about tools that help to reduce the size of level files by letting the user remove all superfluous bloxel and bloxel side data. This is data that cannot be seen - for example invisible cube bloxels with a texture other than the standard texture. Or side data for a side that is completely air actually.
- Ratings for the Alakajam #9 are out, and while I didn’t expect De Moleculis Motus in Vacuo to place very high I am actually pretty disappointed how low the ratings for the audio category are. Of course I understand that it’s hard to hear that I created all my own sounds and made my own music, but somehow this is a very petty community.
2020-06-25
DONE
2020-06-23
DONE
- I streamed myself while playing entries of the Alakajam I participated in, in order to gain some karma so my own game would not fall under the 8 needed ratings. The games I played were mostly interesting and fun to play, and the feedback for De Moleculis Motus In Vacuo is pretty good so far. Experience tells me though that doesn’t usually mean the ratings are positive too.
2020-06-22
DONE
- Fixed an extremely annoying and hard to debug error in bloed today. In the end a single !chunk.Exist in an if() (with two other checks inside) was the culprit. The problem was to find out how to generate the bug reliably, and then to find out what could cause it.
2020-06-21
DONE
- My Alakajam #9 entry has now a name: De Moleculis Motus In Vacuo, and it’s available on itch.io as WebGL and as Windows standalone version. Not the greatest game ever, but it works well enough. I even made some music for it; usually I just use random generators. I composed it with Rytmyk Studio.
https://ratking.itch.io/de-moleculis-motus-in-vacuo
2020-06-20
DONE
- I started an entry for Alakajam #9; the theme is Connections. My project doesn’t have a name yet. Overall it’s very simplistic, which means the gameplay is mostly finished. The player has to remove connections (lines) between bouncing circles, because it’s game over if the connections intersect too often. Tomorrow I want to create some sounds and music; maybe a small local highscore.
https://twitter.com/RatKingsLair/status/1274426956461858819
2020-06-19
DONE
- After several small bugfixes I did the first step of re-adding the Cuboider to bloed. The Cuboider is just the tool that adds/removes several bloxels at once. I will make it a bit more powerful - as it was in Behind Stars’ editor; it was able to change the texture of all surrounding bloxels. (Actually, that was the Framer’s ability, but in the end the Cuboider and the Framer were very similar.) This way you could easily create rooms that would be already equipped with the correct wall texture. Maybe I can even distinguish between wall, floor and ceiling now.
https://ratrogue.tumblr.com/post/621370074116325376/
2020-06-17
SEEN
DONE
- The Texer tool of bloed, which lets you change individual sides of a bloxel, and also the Bloxer (i.e. the standard tool of changing whole bloxels) have now undo and redo. I overwrite the Z and Y hotkeys for that, but they’re both not really used when bloed is activated. The undo/redo manager is a very short piece of code - it just registers a System.Func<bool> (for the actual action, and for redoing it) and a System.Action (for undoing this action). It’s most likely not very memory friendly, but for now it works as it should, surprisingly.
The next step is to re-implement some of the old tools of the old Behind Stars editor.
2020-06-14
DONE
- I now can have subtools again in bloed, so I added (rudimentarily) the old Texer. It allows the user to change the individual bloxel sides’ texture. Right now it only can change the index, but not the offset, so that’s the next step.
Update: apparently I never actually implemented being able to change the offset. Bummer. Other than that it’s mostly feature complete now.
2020-06-12
DONE
- Just a short progress report - I worked on bloed from time to time, mostly improving the editor layout and stuff. Which mostly means I keep putting back the important work, which would be things like being able to change individual bloxel sides, or creating several bloxels at once. I will reuse the system from Behind Stars and Under Hills for that - a collection of subtools that can be individually programmed and optimized. Back then I did them in Lua for a while, but that was much too slow anyway.
2020-06-09
DONE
2020-06-07
DONE
- We streamed again - but not via our own channel. Instead we talked with the people from Silver Seed Games about our game SOLITUNE, and about game development in general. It was pretty wholesome, although I wish some would have asked questions during the stream.
https://www.youtube.com/watch?v=NBNMU30kqVQ - I restructured the whole project for bloed so it uses “bloxels” instead of “voxels” now and is generally nicer to look at. I should send the stuff to some people for testing, but then I’d need to write some documentation.
2020-06-06
SEEN
DONE
- As I did more work on bloed I mostly battled Unity’s serialization system again, and it drove me crazy for a lot of reasons. I should write a blog post about my findings, although the infos are out there already. In the current case I wanted to serialize my bloxels not as references to their types but only as their UIDs - to save a bit of space, but more importantly to not lose those references when I add a new type and have to recreate all templates. This meant I had to save the list of templates separately, so I could recreate the list of bloxels to use their respective templates when Unity deserializes the scene. Which actually became the problem, because it’s not guaranteed that the list of templates is deserialized before the list of bloxels in each chunk. Which means I had to take special care of that, and in my case it thankfully works (after a lot of pulling hairs), but only because the chunks don’t need the bloxel list when the scene gets loaded; only when they get manipulated. Phew.
2020-06-02
SEEN
DONE
- Over the weekend I worked a lot on bloed, mostly doing more refactoring and adding small features like picking bloxel templates and textures. Seeing Oskar Stalberg’s tech is a big downer though, as I question my approach more and more. In the end though it’s just a matter of time - I need to release it as soon as possible, so it won’t result in depression when it’s DOA.
https://imgur.com/gallery/i364LBr
2020-05-30
DONE
2020-05-28
SEEN
- We watched the noclip documentary about Arkane Studios, and a big part of it is about the games they worked on but never released, because of business reasons. I like the idea of the nail gun in the Ravenholm game, which lets you create “paths” of current in a relatively elegant way.
https://www.youtube.com/watch?v=h4kdqwdbZZ8
DONE
- I put the block editor for Unity on github, and named the project “bloed” (block editor); this after I tried to refactor some class and broke the whole project because of that. So finally I can do a bit of experiments.
For the curious, the thing that broke the project and myself was yet again the whole thing with Unity’s serialisation of classes. To be able to reference something more than once it needs to derive from ScriptableObject, which makes a class very heavy. And if you don’t create the ScriptableObject as a real asset in the project, you can’t use it outside the current scene.
2020-05-27
DONE
- We livestreamed once again as Spielgefährten on Twitch, where we talk about games and game design. This time we tackled Ultima Underworld, and - because it is heavily inspired by it - Behind Stars and Under Hills, our prototype that was never meant to be.
https://youtu.be/CGEyjVPPEzo
2020-05-26
SEEN
- Watched this talk about automated game apps that made actual money. Kinda depressing that those guys made more money with actual crap than we did with some ‘real’ games… But interesting nonetheless.
https://www.youtube.com/watch?v=E8Lhqri8tZk - Had to re-learn Rigify again, but thankfully it’s less complicated (at least on the surface) than it looks like. I guess I will remove almost all of the face bones and only keep some for the mouth, eyes and ears.
https://www.youtube.com/watch?v=8JGC32PKc1U
2020-05-25
SEEN
DONE
- The Unity block editor now allows adding new block templates and textures. It’s more than one step though, so far, and the changed texture is overwritten for all levels. Not sure yet if I want that actually. Maybe an interesting way would be to name the texture atlas according to the textures inside, and let a level define which textures it wants. The question is if that is actually necessary?
2020-05-24
PLAN
- Because I semi-lost motivation to continue with the gridder - even though I still like the project and the idea - I want to shift the focus a bit on what to do next. While I do need some kind of working AI with pathfinding for it to become a game at all, I think switching to bit of level design could help with finding out what the game will look like and how it will play. And if some things I am planning are even necessary at all.
So the next step should actually be to write down a bare-bone story that will define what kind of levels have to be made. I know I want monumental, castle-like structures with three-dimensional architecture, but not yet for what and how much of it should be “realistic”.
DONE
- I added a rudimentary 3D cursor to the block editor for Unity. It works differently now than with Morited, but I’m a bit limited by Unity and their already existing controls and hotkeys.
- We created a keynote video for a game jam for the Macromedia Hochschule; we basically gave tips and showed several of our (ancient) jam games. Let’s hope it’s not too awkward for the students; I know it was for me. But it paid off that we do some streaming (as Spielgefährten) now and then for a few weeks, because the style worked well for a keynote and let us do the recording in less than an hour. We used OBS for recording, and it seems it was a bit of a mistake to use MKV as target format of the video, because Jana had problems using it in Premiere Pro CS 5.5 - several attempts to convert it were necessary.
2020-05-23
DONE
- I started to “texture” (more like colourize) the doberman model for the ping-pong project. It feels very old-school, or rather out-dated, to do a semi-manual UV layout and then paint (via Affinity Photo) on the UV islands. I should research on how the modern approach is, although I know don’t want to use something like Substance Painter. Maybe the drawing tools in Blender are good enough?
- Update: a few hours later I actually used Blenders drawing tools to create the texture. As the model is mostly a single colour, it was good enough, and quicker than the back-and-forth to Affinity in any case. Especially as there seems no way to automatically reload the texture in Blender when it was edited in another program. You always have to press Alt+R (when hovering the image window).
- The Unity block editor now has a much better way to set and remove blocks, by using a raycast. Based on Physics though - I tried to use Unity’s inbuilt picking system instead (someone found out how to utilise it), and while just picking a game object worked, casting a ray against it would semi-randomly choose a point on back faces, which is less than ideal. So I had to resort back to the Physics system.
This system of placing blocks is of course much easier to use than the one based on floor grids, but I’m missing the system I had in the Behind Stars editor, where I could place a block anywhere I wanted via a 3D cursor. Without it, you can’t even begin creating a level, because there is nothing you can pick… and creating large rooms was much quicker and easier to do. I will try to find out if that system is feasible in the Unity editor or not, although it depends quite a bit on how the camera system worked in Morited (Behind Stars’ level editor).
2020-05-22
DONE
- The block level editor inside Unity now saves the texture by writing it to a PNG into the project’s Resources folder. This way I can directly apply it to a material. After that I felt fancy and quickly added the functionality to change the placement grid’s height, to be able to actually create 3D structures. Overall the editor plugin is bare-bones, and one messy hell pit of code, but it was fun to try to get it to work. I always regretted a bit that I implemented Behind Star’s editor the way I did, even though it really made level design easier (IMHO) and allowed me to have some really neat tools.
https://ratrogue.tumblr.com/post/618793805971357696/after-some-hours-of-work-i-could-rework-the-block - Additionally I added buttons to choose the block template (air, block, brick, half block, etc) and texture. I needed a bit of trickery because Unity’s IMGUI can act funny sometimes, but it works now. Of course it’s all very rudimentary. In any case, next up would be a preview mesh for what you are currently placing.
2020-05-21
SEEN
DONE
- Worked a lot on the block level editor inside Unity - I was mostly trying to make sense of what gets serialised and what I should replace. Because I hit some soft and hard limits I had to refactor some classes and data structures and now it’s probably uglier than ever, but it kind of works. What is missing right now is a way to save the texture atlas for the materials, so I don’t need to generate that every time.
2020-05-20
PLAN
- Another episode for our live-stream Spielgefährten was done last week (Deus Ex), and this evening there will be another one, about Dark Souls. It’s fun to do this stream because we actually talk about game design now and then.
https://twitch.tv/RatKingsLair
DONE
- While doing more stuff for the Unity-based block level editor, I notice that I am very unsure where should be saved what. Is the generated texture atlas something for the current scene only, or should it be shared between several scenes? Is the generation of the block faces something to be done in a static class, or inside the level script? Is a static class needed at all? What belongs into a ScriptableObject, what does not need to be saved in the editor window? Exciting questions!
- I did some more Blender-ing and “finished” the doberman model. Next steps are UV unwrapping and simple texturing, and rigging. I will most likely use Rigify, because Maximo’s rig doesn’t have stuff like inverse kinematics.
https://docs.blender.org/manual/en/2.81/addons/rigging/rigify.html - I forgot that I did some small stuff for the Gridder; the player can climb now into the correct directions. The problem is that I am still unsure if the project is actually worth it...
2020-05-19
DONE
- I started a little experiment: I tried to import the block-based level creation code from Behind Stars and Under Hills into a blank project and use it for a Unity-based level editing plugin. There weren’t many errors and I am positive that it will work in the end; I already can click in the scene and it creates the chunk meshes as it did in the original. The biggest problem right now is that I use a lot of Dictionaries and those don’t get serialised by Unity, thus changes won’t be saved consistently. I could use OdinInspector, but then I wouldn’t be able to distribute the editor if I’d ever fancy that. So for now I’ll try some of the free stuff to create serializable Dictionaries.
2020-05-14
SEEN
2020-05-11
SEEN
PLAN
- While I have more than enough projects already, I still think about doing a level editor within Unity. So I’m going to research and tinker with Unity’s editor scripting capabilities once more.
2020-05-07
SEEN
2020-05-06
SEEN
DONE
- The Gridder has now a semi-functional player controller again, mostly copied from the former prototype. Climbing is not really working yet, because there is no thinking ahead, which would be needed to use two consecutive waypoint connections.
- While becoming more comfortable with Blender I exported the current state of the doberman guy for the ping-pong project and imported him in Mixamo. As with my last try (the goblin), there are mostly problems with the fingers. I should try to give them more space.
2020-05-01
PLAN
- Somehow I think the Gridder project should be my “two-month project”, but then again I just know it would get too big for that. If I have the movement stuff ready before we officially start, maybe it could work out.
DONE
- I integrated the basic functionality for lifts in the new Gridder, but it’s very hacky and unstable (at least it feels like it). I am sure I will get back to it when I have re-implemented a player and “real” AI. For now it should suffice, and the next step will be thinking a bit more about ladders.
2020-04-30
SEEN
- A short video on exploration, but with a more philosophical / psychological perspective. It rightfully questions the mechanic of a lot of games where you collect meaningless gizmos around a constructed world. Why does it need that, especially if the world is interesting to explore already?
https://www.youtube.com/watch?v=TGxQzbCuh2M - An interesting break-down of the character animations of Tangle Tower, and how to import and use them in Unity. Somehow I didn’t expect modern solutions to still use “craploads of still frames”, with all the shader power there is - but of course it looks a lot better that way.
https://twitter.com/SFBTom/status/1254870214287769602
PLAN
- I’m trying to compile a list of short game ideas that would be doable within two months ideally. Because after the current contract work (CitApp), we want to work on (maybe) Behind Stars, but releasing it will take another year at least. And I’d really like to release something commercially much sooner, so maybe doing smaller projects first is a good idea.
DONE
- Yesterday we did another episode of Spielgefährten, this time we played some local coop games, like Out of Space, Overcooked or our very own Spheroneers prototype. It became a bit more personal, which I’d like to avoid next time.
https://www.youtube.com/watch?v=ck5ZCIG_aAU
2020-04-25
SEEN
DONE
- Not much, but I semi-solved the problem in my recent Gridder iteration with entities falling on other entities. I added a CollisionWithOtherEntity() method, and defines for each case what happens if, for example, a character moves towards another or falls onto another’s head. That method can be extended as needed, and most likely intercepted by the AI and the player classes.
2020-04-24
SEEN
2020-04-22
DONE
- We did a livestream (in German) for our podcast format Spielgefährten. We played the game “Star Trek: Deep Space Nine: The Fallen” (in German), commented on it and talked about us and games and game development in general for more than 2.5 hours. It was quite fun, even though I still hate hearing my voice.
Setting the whole thing up with OBS was nice and easy.
https://www.youtube.com/watch?v=gU8AccKw-LI
https://www.twitch.tv/ratkingslair - I tested 72 a bit more. On our own 10 year old Mac it doesn’t actually freeze, but the physics go bonkers and you can’t leave a room after you enter it. I decided to not bother anymore, as it’s so random what’s happening here and with only one person who showed interest in the Mac version it’s actually wasted time already to just write about it in this log…
https://ratking.itch.io/72
2020-04-18
DONE
- I did some more light stuff for the Gridder; I think the problem “stairs” is not fully solved yet but the outlook is bright, thanks to positions being able to share one waypoint (done via the waypoint objects in the scene). In any case, the random AI walks around relatively sane. Next step will be connections that can be (de)activated, which might lead to usable doors. After that, maybe, lifts, ladders and entities falling onto other entities, “crushing” them.
- Bitbucket warned me that the repository of Behind Stars got too big, so I followed their advice and removed some files. Afterwards the repository became even bigger. I am very sure I made a mistake somewhere, but to get rid of the git-induced headache I just created a new repo on github. This one is now 260mb; the one on bitbucket accumulated over 1.3gb of data. While losing the history is kind of sad/bad, it hopefully doesn’t matter much, as we’re going to overhaul a lot of things completely anyway.
- While I don’t want to see it as a sign or anything, I get the old notebook out much more often now and doodle stuff. I’m still missing some kind of “motive” I want/need to follow, so I get lost in ugly characters nobody cares about instead of doing some meaningful or at least pleasant drawings. Maybe Behind Stars, or the Gridder, or the ping-pong project could be a goal here, but on the other hand I actually should free my head of these projects now and then.
2020-04-16
DONE
- I uploaded our old GGJ game from 2013, 72, on itch.io, because someone asked for it. I didn’t create any new builds, so of course the Mac build freezes… I really don’t know where to begin to fix this, especially as the log doesn’t say anything.
https://ratking.itch.io/72 - Coincidentally, another person tweeted me 2 days later about another 2013 jam game of mine, Soliloquy. I only had a Windows build lying around, so I just uploaded it on Dropbox, but maybe another itch.io upload would be good.
http://fholio.de/soliloquy/
2020-04-14
SEEN
2020-04-10
PLAN
- Now that we’re back thinking about Behind Stars, there are a lot of things I’d like to completely change. From the top of my head, those would be
a) replacing the animation stuff with Animancer
b) replacing the whole ingame UI (ugh) - which means the inventory, the quests, the help system
c) replacing the editor for texts (notes and quests) - the quests could be controlled by a special version of the dialog editor, maybe
d) replacing the torch system maybe
e) finally making cool grass decals
f) replacing the event system with simpler signals
g) replacing the ground fog system with another asset
...and of course much much more.
DONE
- I opened the old Behind Stars and Under Hills prototype/game in the latest Unity 2019.3. Apart from a few warnings it went kind of well. I am scared of my old and sometimes hacky code though.
- A few days ago I implemented “dynamic” geometry in the New Gridder. Which means I can remove a block or add one, and it would generate a new set of waypoints around this position only - thus reducing the amount of involved physics shenanigans.
My next goal should be a conjunction of having stairs in the game, and random “AI” roaming through the level because it usually shows how much everything is making sense. One new approach is to not let characters reference waypoints, but only their position - because waypoints can possibly get deleted anytime, or just not exist (e.g. when falling down). Oh, and I need WayPointObjects and WayConnObjects, which inherit MonoBehaviour, so I can add extra data to a level.
2020-04-05
DONE
- I’m finally doing a bit in Blender again. After I created that Goblin for another project (even rigged and animated it a bit) I felt good about myself, but of course I let it drag until I barely knew any 3D modelling. But now I am doing another character, and while it feels harder than before, I still enjoy it.
- The reset of the Gridder was helpful to rethink my actual intentions, but it led me to question everything I’m doing right now in Unity. The current target is to have dynamic waypoints that can be removed and added without problems. Of course there are a lot of raycasts and sphere overlaps involved right now because I do it based on blocks, walls and ceilings/floors. But it feels it’s the right direction, and for now it works.
“Different heights” is a goal I won’t pursue anymore, at least not as I was envisioning it before; but stairs should be possible if I let two waypoints share a world position, basically telling them they’re twins, or even the same waypoints.
2020-03-29
PLAN
- I think I want to “restart” the Gridder project, basically making a new movement prototype. This would be the fifth time then, if you count my failed 7DRL from 2016 and They Look Strange And Have To Die too. I want to get back to the original 2016 movement, as I don’t think I won’t need some of the specific features I added in They Look Strange, like having multiple enemies on one grid tile. Instead, I really want to have climbing, which my current prototype also has but (IMHO) awkwardly implemented. The climbing should need two turns (one going up, one going forward) to give it more impact. One thing I always never knew how to handle is what happens if the player lands on an NPC - currently I can push the NPCs away, but what happens if there is no space? In the current prototype it’s possible to have several characters on one tile and that helps, but it can look strange and not work always (needs a more sophisticated system of finding the next free tile for that). So my new idea is to just give every character - NPC and player alike - an “unconscious” state, where they are immobile and reduced in height, to reduce strange clipping errors (for the player this would lead to a third-person camera, and/or death).
It would also be very okay if the player has more movement possibilities than the NPCs; most games are like that anyway. So while the NPCs could be able to climb, they don’t need to be able to jump across a gap. Especially if they get other abilities in turn, e.g. using far-range weapons (stones, spells) anytime they need to. I can also give them the ability to switch places. All in all I want the game to really feel like a roguelike, but in 3D and (probably) with designed levels.
Now what to do about doors? It would be great if NPCs can use doors, and especially open them on their way to hunt the player. Doors could either take up a whole waypoint/block, or sit between two waypoints, on their connection. I think I will reduce complexity here as well and just give waypoints and connections special flags that mark them as doors, and thus easy to identify for pathfinding algorithms. Platforms that move a character from spot A to B can exist too, but would probably only be usable for the player.
One feature that was in the 3rd prototype actually, but not the latest, and that I’d really like to get back to, is different heights. It interferes a lot with the climbing (and falling) abilities, but it would allow a much more diverse looking environment I think. As the base block size is around 2x2x2m, I would probably define every height difference above 0.5m (i.e. 25%) as climbing, and 0.5 and below would be a direct connection. The whole ordeal can lead to inconsistencies with characters falling from different heights, so this needs to be reevaluated for sure.
2020-03-27
DONE
- We uploaded the GRITO GRIOT game we made during (and after) our stay in Salvador de Bahia, Brazil. It’s mostly a random rhythm one-button shooter with a very special story about sci-fi brains and robots, and also a music instrument called the berimbau (look it up). Unfortunately the beat detection never really worked as good as I wanted, but it’s interesting to look at in any case.
https://ratking.itch.io/grito-griot
2020-03-26
SEEN
- Watched this video about stealth game mechanics (it’s the first part, about how guards detect the player). For my taste it mashes stealth puzzle games (e.g. Marvellous Miss Take) too much together with stealth action games (e.g. Thief), but I guess the underlying mechanics for the NPCs are the same or at least similar. It doesn’t go into cover-based vs. “brightness-based” stealth, which is probably okay. I just don’t like cover-based-only stealth, because usually it needs a lot more user interface to make the player aware if they’re seen or not.
https://youtu.be/Ay-5g36oFfc - Funny/interesting abstraction of driving physics. And it’s exactly what I would rather do than trying to get real car physics right for months.
https://twitter.com/Nitroneers/status/1238779466832363520
PLAN
- I’d like the ping-pong project to be a bit of an immersive sim; unfortunately I can’t find a certain video I once watched about what makes an immersive sim. IIRC all there is to it is just having things that react to events. Thief would solve this by actually spitting out an event (i.e. a message with an unique ID and some information, I guess) anytime anything happens. Sound designers could grab any event they wanted and add a sound to it, making the experience great for the designers, and the players.
https://thehistoryofhowweplay.wordpress.com/2018/11/30/thief-the-dark-project-20th-anniversary-oral-history/
DONE
- I actually created a Signals class for the ping-pong that could replace my Events class from my base code. It feels a bit more elegant because it is simpler overall, but only real use will show if that’s actually the case. I also tinkered a bit more with the character controller, and while it still has a lot of flaws, it is done for now. (First problem to note: there will be glitches if the player stands up under a low ceiling.)
2020-03-20
DONE
- I tried to make the character controller for the ping-pong project force-based. This is because I think directly manipulating the velocity will bite me in the ass when it comes to interaction with physicalized objects like crates. Yesterday I also added running by pressing Shift; nothing fancy. It will probably be better to invert it and make the character slower when pressing the key.
2020-03-18
SEEN
DONE
2020-03-15
DONE
- I added some old code from the StealthGridder version I did in 2018/2019 to the ping-pong project, so we can have a light gem similar to Thief. It’s missing a correct detection of spot lights, but at least I found and fixed a bug from the original version.
- CAPTCHA does accept input by the user now and compares it with the current string displayed in the letter noodle soup in the background.
2020-03-14
PLAN
- I remembered West Bank, a very simplistic game on the C64 about being a bank clerk, receiving money and shooting robbers. When we played it back then my brothers and I would concentrate on one door each (there are three) - we still didn’t score a relevant high score. In any case I thought about transforming it into a VR game. I think it could be an interesting project, because easy and yet extendible.
https://www.youtube.com/watch?v=is5KnA-EcTs
DONE
- For the ping-pong I created a basic character controller for the player. It’s possible to walk and look around. I pretty much recreated the physics-based dynamic character controller that I always use; mostly because I wanted to see if I would “improve” something if I’d try it from scratch. I do believe it’s already somewhat more robust thanks to using Rigidbody.MovePosition() instead of transform.position for setting the character’s “leg height”; but only time will tell if that’s actually useful.
- I did some kind of code clean-up in my Gridder project, because a lot of things I did so far were hacked in. It’s not substantially better I guess, but at least I named things more clearly and also use events now instead of coroutines at some places. Next step I should try if I can add waypoints dynamically without much hassle; those are missing from They Look Strange And Have To Die. It might also be interesting to try if I can make the y coords of the waypoints a fraction of 1; this way, stairs would make more sense.
- I downloaded Mirror today and got the first example working without any problems. The code of this super simple demo is already interesting, so I will definitely try it out. The ultimate goal is a prototype for Spheroneers that can be played via LAN at least, so we won’t have a couch game only.
https://mirror-networking.com/docs/
2020-03-11 / 2020-03-12
DONE
- Did work a little bit on CAPTCHA. Working with UGUI and TextMeshPro is actually okay, if one knows which of the obscure methods one has to use to get the size of RectTransform and text bounds.
Spawning hundreds of TextMeshProUGUIs (horrible class name, by the way) produces only 6-7 draw calls, which is nice.
2020-03-10
DONE
- In order to implement doors for the Gridder I actually extended the WaypointPhases class to not only manipulate waypoints but also connections. The class became a bit cumbersome, because with Unity’s serialization system I can’t use polymorphism just like that, and now I have four arrays for the waypoints and connections to activate and deactivate per phase. What’s missing now is actually sensible animations for the door objects in the world.
- I created a Unity project for the ping-pong project, with the goal to make it a stealth/hacking game. (Don’t ask how that happened.) Stealth is one of my favourite genres, but I also know it is pretty hard to make. Even though we made The Sun Is Deadly aeons ago I don’t think it will be a matter of a few evenings only to create a good enough hide mechanic.
2020-03-07
PLAN
- It was clear before probably, but the 7DRL this year won’t be finished. Debugging it in Unity is just too slow with my current setup, and I am not really convinced of the game’s concept anymore either.
- There are now Interactables in the Gridder, so the next step can be adding doors. (This also means one can enable/disable connections too.) I need a sensible way to logically connect interactables (and their effects, e.g. opening up a pathway) with waypoints, so the AI can use them too in some manner. I am sure this will need a lot of thinking in the future.
2020-03-05
DONE
- The 7DRL project is going forward much too slowly. Only now I got the movement back that I had in Wood for the Trees, mostly. I guess I should have looked at my old code, but I fear old code sometimes. At least the export to the Oculus Quest is no problem; the actual issue for me is that one needs a beefy PC for impromptu testing of a VR game in the Unity editor, and my laptop is not beefy. So right now I constantly build the game on the Quest, which is a time waster and not very motivating.
https://forums.oculusvr.com/developer/discussion/82363/oculus-link-unity-set-up-guide
2020-03-03
PLAN
- The ping-pong collaboration project is, once again, going to become another type of game. We might want to do a Zach-like for it, with dungeons and mechanical goblins. It sounds fun already, in my opinion.
DONE
- I worked a bit more on the 7DRL, not really following the time plan I did. At least I now understand better how creating a game with Unity for the Oculus Quest works. I should get that emulator going, for quicker play testing, because right now the constant switching between headset and laptop is giving me headaches.
https://developer.oculus.com/documentation/unity/book-unity-gsg/ - The Gridder now has semi-working lifts, activating and deactivating waypoints. The code is a mess and I should clean it up sooner than later, otherwise it will bite me in the future; especially as I don’t work on the project consistently. Other than that I am happy with the progress; next up will be interactable things - like doors, which also need to be able to activate and deactivate not waypoints but connections between waypoints.
An interesting challenge will be to make AI agents understand that a blocked connection can be unblocked by just opening a door. It might involve even more trickery with waypoints having additional information about their connections.
2020-03-02
PLAN
- I began a Unity project for our 7DRL entry. We plan to make it a VR game, because traditional roguelikes are done a lot already, and we want to experiment. The idea is to create a game that is spatially similar to Wood for the Trees, but randomly generated. Like most action roguelites, each room will have a wave of enemies coming at the player, which they have to shoot. Only then they can proceed to the next room. Each room will probably be pre-designed, consisting of ruins and plants. The enemies are planned to be skeletons. That will most likely be more than enough already for the sparse time we have left while doing contract work and other things on the side.
https://itch.io/jam/7drl-challenge-2020
DONE
- After already having done it on my office PC, I now could export an APK directly to our Oculus Quest on my laptop. Quite a feeling, even though we already made Hands Off Thief some years ago.
2020-02-29
PLAN
- For the Gridder I thought a bit about how to create dynamic level elements, like moving platforms, doors, traps and things like that. As I want the system to be conflict-free and mostly predictable when it comes to the creatures moving around, I will have to make it a bit more complicated to use (as a programmer and level designer). Right now I envision waypoints that can be activated and deactivated, and scripts with “phases” which define which waypoint is activated when. Between two phases, all of their waypoints need to be deactivated, to make sure no entity (character) is doing unforeseen movements. So when a lift is moving up, it deactivates the waypoint on the ground and activates the one at the upper target point. All characters on the ground waypoint are moved to the target point - this can be instantly or (in this case preferably) with a tween. It would also be possible to kill all characters that would occupy a waypoint that is deactivating - or just give feedback that the phase can’t be set.
For doors, i.e. walls/obstacles between two waypoints that can open and close, it actually doesn’t have to be this complex. It would only involve a connection that is either passable or not, and an object (the door) that would be connected to it somehow.
2020-02-27
SEEN
PLAN
- For CAPTCHA I should think of an interesting play progression. At an exhibition I think a game not lasting longer than five minutes would be okay, but it still should have some kind of difficulty curve and a satisfying end each time.
DONE
- Fixed a bug with the “AI” in Spheroneers (the enemies continued with their mindless attacks even when a player was still near but not in their view direction anymore). There still is that problem with the enemies not reacting at all though, and I couldn’t replicate it so far. In any case, I think it is now much more ready to showcase it at the Talk&Play in March.
- I finally created a Unity project for CAPTCHA. I thought about doing it in Heaps or something else, but Unity’s text rendering capabilities are pretty much the best I have, and that’s what’s important for this project. I also feel proficient with UGUI nowdays to actually be productive with it.
- Had a dev meet-up via Discord with voxel, and it only worked on Chrome. Both the app and Firefox refused to recognize my microphone. Strange stuff.
2020-02-26
DONE
- Seems like my problems with VSCode (see 02-25) were happening because I had a git related extension active with the project not being a repository. Success, for now! Enabling all the extensions feels like bloat anyway; although in any case such things should never happen, especially not without any hint of what's going on.
- I created a new version of CHIPCODE specifically for Linux, which replaces the TextMeshPro objects with normal TextMeshes, because only those made problems - and only with this specific font too. I should write a bug report.
https://alakajam.com/8th-alakajam/856/chipcode/ - The dash mechanic was kind of easy to implement for Spheroneers; but of course it might be a bit overpowered now. For the prototype it will suffice. All it needs is to add a hint text about it somewhere.
2020-02-25
PLAN
- I noticed that Heaps actually has some basic GUI elements too; not immediate, but that shouldn’t matter. Maybe I’ll try to make the dialog editor (if I will do it at all) with Heaps then.
https://heaps.io/samples/
DONE
- I started to add a dash mechanic to Spheroneers, but VSCode acted up again and it lost all Intellisense functionality. A maddening circumstance, and the various solutions to this problem don’t work so far. I even could add the missing .sln file, and still no dice.
2020-02-24
DONE
- I added CHIPCODE to my website. A Linux user commented they don’t see the text on the chips, but I cannot reproduce that unfortunately, and other Linux users said they don’t have that bug. Oh well. An after jam version would be nice though, with one or two more tasks, more chip types and the possibility to save progress or at least choose levels.
http://fholio.de/chipcode/
2020-02-22 / 2020-02-23
DONE
- I participated in the 8th Alakajam and made CHIPCODE in less than 48 hours. It’s basically a “programming” sandbox strongly inspired by Zachtronics, for example TIS-100. For a real coding game there are probably too many options missing, but a lot of stuff is there. In the end I never studied Computer Science and it shows.
The theme of the jam was “Depth”, and while I was kind of inspired by it, the result doesn’t have much of it anymore, as I had to re-scope and change the functionality at important points.
The hardest part was the “recursion” of the small chips boards, and I am still not sure it is correct now. I might get back to it later. Unity 2019.2 crashed annoyingly often, especially as I never had this problem with former versions of Unity.
https://alakajam.com/8th-alakajam/games
https://alakajam.com/8th-alakajam/856/chipcode/
https://store.steampowered.com/app/370360/TIS100/
2020-02-21
DONE
- I worked a bit on my Gridder project and actually didn’t do what I planned last time, because it dawned on me it would interfere with my current logic for force pushing characters out of the way. Instead I extended the waypoint generator and now it automatically generates connections for climbing up and down walls. This involved a lot of raycasts, so I’ll see later how robust this is when I (try to) make the connections more dynamic.
- Because of boredom I added “shooting bullets” to the ping-pong C project, and ditched the Snake mechanics for now (because voxel doesn’t like them).
- VSCode’s auto formatting stopped working suddenly. Had to research what was wrong, and I still don’t really understand it. A lot of small annoyances are happening, but not enough to change back to VS Express. Not yet.
2020-02-20
PLAN
- At some point I’d like to try another networking game - Karoshi! It was so long ago, I don’t really know if I could do it again just like that. Also, the inbuilt multiplayer support in Unity is shaky at best and they are constantly trying to make something new and better; so it’s wise to not wait for it. After a first few seconds of research the most viable options are Photon, Mirror and Forge. In any case, for Spheroneers I will definitely have to look into some options in the near future.
http://fholio.de/karoshi/
https://mirror-networking.com/
https://github.com/BeardedManStudios/ForgeNetworkingRemastered
SEEN
DONE
- The after-jam version 0.7 of Spheroneers is now live. We basically only added sounds and replaced the music. Of course some bugs were fixed (like a missing animation, or characters falling through certain floor tiles), and it’s much more clear now that walls can be repaired again after you destroyed them. I also added keyboard support (rudimentary), and it’s better handling a single player now, if there is a need for it.
https://ratking.itch.io/spheroneers - We showcased Spheroneers at the 18th GameDev Leipzig Meetup with both a 5 minute presentation and letting people play the game, and it was cool. Naturally there weren’t many players (it’s only Leipzig, after all), but a lot of fun was had and some feedback was given. Seems like we need to ramp up the “juice”. A problem is the back-tracking which destroys the flow a bit - more checkpoints would help here. It was a bit chaotic when three people played it (instead of the usual two), but then the fun was also bigger I think. And of course a lot of glitches and bugs became apparent, but nothing serious.
2020-02-19
SEEN
- As someone who is allergic to learn git properly, this might be useful.
https://gitexplorer.com/ - MyPaint looks like a pretty lite alternative to Krita and other paint programs. Might have a look into it, if I ever do some digital drawing again.
http://mypaint.org/
DONE
- On my laptop I actually use VSCode for everything coding related now - C, C#, Haxe. After having problems with the auto formatting with C#, especially as the FixFormat plugin doesn’t seem to work when it comes to keeping my curly braces on the same line, I found this github issue regarding OmniSharp, which solved the problem.
https://github.com/OmniSharp/omnisharp-vscode/issues/1506#issuecomment-303390666
2020-02-18
DONE
- I worked a bit on the Spheroneers after-jam version (0.7), mostly adding physical scrap objects as feedback for having walls and floors destroyed and repaired. It looks funny already. Big annoyance today was the totally strange behaviour of the players’ character controllers suddenly. They got stuck on small slopes and wiggled around stupidly. The latter I could solve by replacing rigidbody.Rotate() with transform.Rotate() in the Update() method, but the former was a conundrum. Asking around didn’t gain anything. And now, after restarting Unity, it works again as it should. That is not really good, more like worrisome, but I will take it for now.
In other news, we requested Nintendo Switch Access, meaning the project might become quite a bit more serious in the future. Here’s fingers crossed. Although we are still searching for the full game’s core principles and setting. Doing research on similar (and successful) games is also making me a bit depressed. - As I don’t use my Tumblr anymore, but this simple log instead, I updated my website’s link section. This is the first “official” appearance of the log anywhere.
https://ratrogue.tumblr.com/
http://fholio.de/about/
2020-02-17
DONE
- I added buffered input to the Raylib ping-pong game, as planned. It was a lot more complex than in any language with dynamic data structures (a simple List for example), but I am sure the real problem is my rather fragmentary knowledge of C. It probably would also have been easier if we’d support only one key per movement action (e.g. A for moving left). Overall I liked it, but I can see that handling this project can become very frustrating as soon as there’s more stuff going on.
https://github.com/pixelsyntax/coolfriends-pingpong/commit/ee4e83e82a3c41c2a8e7335c8cd1f0f401dc57e8
2020-02-16
PLAN
- A very old prototype of mine, CAPTCHA, needs to be extended and polished for a typography exhibition. (As I promised it to the people from lalalab.) The old prototype actually uses an ancient version of Unity, but I think it would be an even better fit for the “new” UI of the latest Unity versions.
http://www.lala-lab.de
https://youtu.be/ba2dlK9zBHA - For the problem of distributing differently sized characters in my Gridder project I decided (for now) to go with a sub-tile system. So each waypoint would consist of 4x4 sub-tiles that can be deactivated individually. Creatures are sized 1x1, 2x2, 3x3 or 4x4; 2x2 and 3x3 are the most common ones; if they don’t find any free space, they can’t go. The problem becomes like a simple texture packing algorithm; so I will probably try to sort characters on a tile by size, with the biggest ones first. Otherwise it could happen that a 3x3 creature doesn’t fit even though less than 7 1x1 creatures are there too. I don’t know yet if I will have such small creatures anyway.
- Current plan for the Raylib ping-pong project is to add buffered input. Afterwards (maybe) basic Snake functionality (getting longer), and an endless procedural level. Sounds fun to me at least, and it’s what I think I can actually do with C so far.
DONE
- Did some work on the jam version of Spheroneers, because we want to showcase it in Leipzig, at the GameDev Meet-up this Thursday. So I added an arrow in the UI that would always display the direction where the sphere currently is; for that I have to find the intersection of each border line of the view with the line between the centre of the screen and the screen position of the sphere. Probably not the fastest solution, but the most correct one. I was too lazy/dumb to think of intersection maths, so I got it from the link below. The C# code only returns true/false depending if the lines actually intersect, but getting the intersection point was easy enough.
https://www.spieleprogrammierer.de/wiki/2D-Kollisionserkennung
Next up: some particle effects, for the feedback and overall polish. So far we mostly received mixed reactions on the game, in the vein of “good idea, but probably not successful”. Hmm.
2020-02-15
DONE
- VSCode + Unity seems cool so far, although I find the references by code lens somewhat too big. I might disable it just because of that. Also the integration of VSCode is not perfect in Unity 2018.4, and I don’t know if I want to switch all my projects to Unity 2019. On the other hand not having 3 versions of Unity installed might also be nice.
- Out of curiosity, and to (re-)learn C a bit, I compared the speed of getting and setting values in a single dimensional array A versus a two-dimensional array B. The result isn’t really conclusive, because I calculate the index for array A, which I don’t have to for array B, so of course B is faster. I could maybe “optimise” it by just using an index counter for A. More interesting though is the fact that (at least for this online compiler) a two-dimensional array of the size [1024][1024] is too big; it will segfault; while array A with size [1024*1024] works fine.
https://onlinegdb.com/BJuS54H7U
Making the arrays static (that means, putting them on the heap instead of the stack) works though. Still, I wonder why array A doesn’t have a problem with the size. Is it always allocated on the heap?
https://stackoverflow.com/questions/851122/large-2d-array-gives-segmentation-fault/851135
2020-02-14
SEEN
- I finally read this hands-on article about the View Cones in Shadow Tactics. I think the most interesting part for me was how they render the cones, and how they iterated on the detection/flee mechanic.
https://www.gamasutra.com/view/news/290733/
DONE
- Felt adventurous today and installed everything needed to use Unity with VSCode instead of VS Express. The next few days will probably feel strange; especially as there wasn’t a real need to switch.
https://code.visualstudio.com/docs/other/unity - I downloaded Blender 2.82, but still don’t really have a project that might make sense. At least I know now that Armory3D is compatible with it. I also found out that it’s easy to import 2.81’s settings into 2.82; losing my settings was always a problem I had with the portable versions. No more!
https://www.blender.org/download/
2020-02-13
SEEN
DONE
- I use this Google Doc for my log because it provides the least friction possible, and I can actually publish it to make it visible for everyone. Problem is that a published Google Doc is very ugly, the text goes from the left to the right screen border, which works great on a phone, but not so well on a PC browser. This is why I embed the published Doc in an iframe. Unfortunately this results in all links opening inside the iframe. My research suggests that this is not that easy (and crossplatform reliably) to circumvent. Best would be the <base> tag, but it’d need to be inside the embedded html, not the html that does the embedding. In the end I found some JavaScript that helps though.
http://fholio.de/log/
https://stackoverflow.com/questions/4377324
2020-02-12
PLAN
- I should learn and use Unity’s new Universal Render Pipeline, at least for a small project, just to evaluate it. Felix ported some samples, those might be a good start.
https://twitter.com/____herbst/status/1227406553348747264 - There are many things still missing for the StealthGridder to be even considered as a foundation for an interesting gridding game, but one step at a time. So next I might implement a more dynamic way to distribute characters on one 1x1m tile (aka waypoint). It will probably be based on a rectangle (if I should ever introduce a maximum height for a waypoint, it would become a cuboid), with offset and width and length. The rectangle would also define the maximum capacity of the waypoint. To make it even more interesting, a rotation angle (for slopes/stairs) should also be added, but that might also just be solved via raycasts.
The distribution itself could be solved via Poisson maybe, or I try to think of something simpler. This is for four characters on one waypoint at max, after all. - The WobbleAnimations in my base code use scaled deltaTime - why didn’t I notice that earlier? I fixed it in CitApp, and need to integrate that.
DONE
- Finally copied most of my player input code from the old StealthGridder project to the new prototype, and it mostly works. Gamepad support as early as possible is one of our mantras.
https://ratrogue.itch.io/stealth-gridder (old prototype; not public) - Unfortunately zui produces a lot of errors/warnings for me when I use it with the JS target. I didn’t find anything about these messages, so I fear there is some misconfiguration on my part, and I am not sure I want to go down that rabbit hole. Meh. I wrote an issue on github at least, although I am sure this is not reproducible.
https://github.com/armory3d/zui/issues/115
2020-02-11
DONE
- Nowadays I can’t live without Dictionary<K,V> and other data structures anymore. Which is why I’d need them in C too, if I really want to pursue this way further with raylib and raygui. The awesome-c list seems like a good start to find libraries for this, and from the clean look and the (hopefully) ease of use, I like LeoVen’s collection of macros best so far. And I heard good things about stb. I used uthash before, but unsurprisingly I already forgot how to use it.
https://notabug.org/koz.ross/awesome-c#data-structures
https://github.com/LeoVen/C-Macro-Collections
https://github.com/nothings/stb
http://troydhanson.github.io/uthash/ - As I’m still in the research phase for the Unity-free dialog editor project, I’m looking at other libraries that might be a good fit. Especially as I fear that my C knowledge will never be good enough for a complex interface beast like a dialog editor; but for now I know that the rendering problem would be solved with raylib and raygui, and that’s good already. Anyway, apparently there is an Immediate GUI library for Kha worth checking out, called zui.
https://github.com/armory3d/zui
zui is like GUILayout in Unity, which can make it very easy to use, but also somewhat inflexible. I guess I need to reevaluate what my old dialog editor had and what it actually needs. - Added the operator overloads to the Variable SOs in my base code, but much less than I thought I would. Mostly because it was not needed (thanks to the implicit cast to the base type, so I don’t need to overload comparisons for example). It also could be dangerous - as the user (me) sometimes wouldn’t know if an operation manipulates the variable or not. So it’s actually more safe to just use the Value property of a variable object.
https://github.com/ratkingsminion/game-jam-base-code
2020-02-10
DONE
- To go further with my Unity-free dialog editor I created a VSCode project with raylib and raygui. After a lot of fiddling, the “Hello World” kind of works. My biggest gripe right now is that I need to specify the absolute path to raygui.h as include, because otherwise the compiler can’t find it. Which is strange, as I actually defined the path to raygui in the c_cpp_properties.json file from VSCode. I hope I can get an answer to that. Creating C projects correctly is hard.
https://github.com/raysan5/raygui/releases
https://github.com/raysan5/raylib/wiki/Using-raylib-in-VSCode
https://code.visualstudio.com/docs/cpp/c-cpp-properties-schema-reference
Okay, seems I just forgot that the actual build process is defined in the Makefile; task.json gets ignored mostly (maybe one could change that), and c_cpp_properties.json is only meant for Intellisense anyway. Had to hardcode raygui’s source path into the Makefile. I am sure there’s a better way. - We prioritized the tasks, or rather wishlist, for the extended version of Spheroneers by hanging cards on the wall with points like “Get a Switch dev account”, “Graphics style experiments”, or “‘Ramps”. Hopefully we can show a somewhat improved version at a Talk&Play (Berlin), a GameDev Meetup (Leipzig) or at the A MAZE (Berlin); but if not it wouldn’t be that bad. We still have contract work to do after all.
https://ratking.itch.io/spheroneers - I followed this tutorial to create a website with Eleventy (@11ty) - a static site generator. Seems a bit outdated, the index.html generated in the end didn’t quite match the one in the article.
https://www.filamentgroup.com/lab/build-a-blog/
Overall I am not sure if Eleventy, as nice as it is, is suited for my needs. (A simple website for this dev log.) Especially as every entry would need to be in its own file. On the other side I might just use static sites for that (like an About, etc.), and ignore blog entries, or use them for something else (pictures?).
Here’s another static site generator, called Nice, written in and with Haxe:
https://github.com/gmisail/Nice
But maybe I actually should use something totally different; or something I write myself. (But with what?) So for now I keep using Google Docs; I dislike having to rely on an external document system, but at least with Chrome I can have them offline too. - I never really knew how to create an (empty) file in the DOS prompt / terminal. (Or I forgot.) Now I know:
> copy NUL out.txt
Apparently there are several other solutions for this..
http://stackoverflow.com/questions/1702762/how-to-create-an-empty-file-at-the-command-line-in-windows
2020-02-08 / 2020-02-09
PLAN
- I should add operator overloads to the Variable ScriptableObjects for my Unity base code.
https://github.com/ratkingsminion/game-jam-base-code - I want this dev log to be online and public some day, I might have to look into a simple static blog generator. Or something else?
https://haxe.org/manual/target-php-getting-started.html
https://www.11ty.dev/docs/tutorials/ - My StealthGridder project needs mouse look, as a small next step. Right now it’s a bit of an extended movement prototype in comparison to They Look Strange, but it’s also lacking a lot, for example the dynamic levels.
https://ratking.itch.io/they-look-strange - I want to try pure Kha soon again; it’s now usable with VSCode, and I have Kha installed and can use it from the path directly. The “art project” might be a good fit as a project - simple, grid-based, multiplayer. Of course, another big step would be the arcade cabinet (?) itself.
- I should check out raygui to see if it would be usable for a dialog editor.
- The raylib project workflow would probably benefit from using VSCode, because right now I’d have to edit the Notepad++’s build script if there are more .c files.
https://github.com/raysan5/raylib/wiki/Using-raylib-in-VSCode - It would be interesting to try out VSCode for Unity. I probably still need Visual Studio to be installed though, as some libraries (e.g. Kha) need the compiler for Windows builds.
https://twitter.com/RatKingsLair/status/1226047630184243200 - Idea: I could and should do some small visual scenes, probably in Unity, by reusing art I have from Jana and myself, from jams, prototypes and games. And put those to small scenes, with interesting lighting even.
- Spheroneers was a big achievement for us, and we want to extend it. The question is: how to progress from this point? I think a single player mode (that is fun) is needed. But also an interesting style, and more people testing if it actually could be successful.
https://ratking.itch.io/spheroneers - I added a new tool, Voxelator, to my list of free online game dev tools.
https://onlinegamedev.tumblr.com/
DONE
- I checked out HaxeUI, because I want to make my dialog editor (originally for Behind Stars) more independent some day. Seems like HaxeUI isn’t exactly a good fit, because there is no inbuilt line drawing functionality and so on. There are plans for cross platform canvas access, but they are just plans. The HTML5 target creates an actual DOM tree, which would make it hard for me to make easily draggable components. Instead I will probably try raygui soon.
https://github.com/haxeui/haxeui-core
https://github.com/raysan5/raygui - For a ping-pong project I re-tried raylib. Version 2.6 is the current release, but it doesn’t have an installer, so I used 2.5 again. Which was a mistake, because some things really changed; for example, Camera2D.target is now what Camera2D.offset was. In the end I removed all the relevant files from the install version on my laptop and replaced them with the 2.6 version from github. Then I built 2.6 by using F6 in the special Notepad++ make command. It was easier than I thought.
https://github.com/raysan5/raylib/releases
https://www.raylib.com/cheatsheet/cheatsheet.html - I tried Armory3D this weekend a bit more seriously, by “porting” the box-based game jam game I usually do for university courses. Armory3D actually is kind of nice, and does not have a lot of friction. Both the visual coding and the Haxe “Traits” are interesting. You also don’t have to download a special version of Blender anymore; just use the one you have. The tutorials on the git wiki helped me get started.
It’s seriously lacking a 3D text mesh. I wanted to let the camera follow my player, and there wasn’t any LookAt() functionality. There is also no Slerp() for quaternions. Overall it’s not suitable for me.
https://github.com/armory3d/armory/wiki/playground
https://twitter.com/RatKingsLair/status/1226268252336201728 - I tested UMotion, an animation plugin for Unity. It feels very powerful, and yet somewhat easy to use. If there should be any need for this in the near future, I would be happy about it.
https://assetstore.unity.com/packages/tools/animation/umotion-pro-animation-editor-95991
