When the year is ending, it is always interesting, valuable and self-educational to look back and reflect what I kind of development I have done. Some distance allows me to see if I achieved anything worthwhile or if I improved my skills.
Year 2019 was interesting since I was still recovering from health issues which almost devastated my physical health during 2018. Even when I was not in 100% working capacity, I somehow managed to develop number of features for ROT-8 and Planetrism. Probably I have forgotten to list some features, but this seems to be quite comprehensive list:
ROT movement system
ROT camera system
ROT AI player
ROT ballgame camera director system
Machine Learning & AI - Computer AI learns to play ROT
Git tutorials and reference for UE developers
Basic multiplayer tutorial
Multiplayer physics objects, grabbing etc
Multiplayer mountable flying and walking exoskeleton robot which can use its arms as legs, and manipulate things
Several other newsletters
Comprehensive hierarchy and system for surface, physical materials and object types, to support better game mechanics using object identification used in path finding, interactions and procedural generation
Generic animal and NPC framework with AI behavior and task system
More stable car physics
Procedural colony building system
NPC AI visual path finding system (non-NavMesh) using environment analysis
Self-driving robot car system with visual path finding, obstacle avoidance etc.
Winch and towing system
NPC driver and passanger system
Generic communication system for animals, robots and NPCs
Grappling hook and rappelling
Procedural dynamic environment and ecosystem
You can watch this as a video in YouTube
Year started with our side project ROT-8 game which has different game modes like adventure mode, capture the flag and ballgame. There were two primary challenges in its development. ROT-8 is physics based game, where the player pawn is just a cube, meaning that it has no clear front side. It can move in any direction, and use jump engine. Not only is the design of controls peculiar, but it makes it very interesting to design a camera system that makes playing as smooth as possible. So, I put it my goal to develop an automated adaptive camera, which minimizes the need to adjust camera manually, while keeping important game elements in focus, and player still has option to turn camera manually. Although there is still some room for improvement it seems to work quite well
Capture the flag and ballgame needed AI players so I had to develop such. Since AI and machine learning are my main skill area, it was really interesting to make AI players that can learn to play ballgame in co-operative manner as a team, and use some basic strategies. Ballgame needed also an camera director system which could be used either manually or totally automated, switching from one camera to another, choosing automatically good angles, so that viewer can understand what is happening in the game.
I also continued to put out a newsletter with tutorials and other stuff. I wrote a two piece tutorial on effective Git use for UE developers. Later I also made a lengthy tutorial on how to make a basic multiplayer game in UE with only Blueprints. I also had to create an example project where I used Kimmo's Moonbase assets to show a concrete environment for player pawns and multiplayer interactions. Those multi-limbed robots were an interesting experiment, since their limbs are both arms and legs. Robot can walk with them, but it can also use them as arms to interact, grab items and manipulate tools. Walking animation is totally IK-based, there are no animation blueprints at all.
Actually, I prepared lots of other stuff for newsletter and tutorials like
multiplayer physics object interactions,
multiplayer exoskeleton robots with articulated limbs
Procedural colony building system
and some other subjects (that I was developing in my projects), but I noticed that these tutorials and newsletters just did not find enough interest. There were couple of readers, but they did not generate that much interaction that I could justify spending large amount of hours on writing them. My primary purpose was to arouse some discussion, swapping ideas and experiences, but that just did not happen.
Based on those statistics, I decided to put this newsletter on hold. I understand that my writing and skills are poor, and I am not a media celebrity, which are both also a valid reason to discontinue posting any more newsletters or tutorials. Besides, it seems that these times are such that it is practically impossible to have any kind of intelligent communication. Extreme polarization, constant trolling, whining and self-centered attitudes combined with algorithms that endorse only click-bait content intended to trigger people is not really a fertile ground for serious discussion which tries to focus on boring subjects like programming, algorithms, artificial intelligence etc.
While I was developing ROT-8, I was also preparing a big overhaul of everything developed for Planetrism so far. We started the development with such speed, that after a while there started to appear all kinds of problems. Hasty start was one reason for this problem, but the bigger reason was that since our focus was Virtual Reality in the start, and the whole VR field was largely at experimental stage, many things were developed with ad hoc mentality. The lack of coherency in the implementation started to show. There were independent solutions to different features.
Problem was not in the game design, since our vision of game and its features has not changed. We knew that it is large and complex, and it will take lots of time to develop. The problem was in the implementation, and we just had to refactor and redo most of the stuff - otherwise there would be serious problems maintaining and expanding the game.
That refactoring took lots of time, and partly it is still going on, one component after another. But it is necessary, since it will make further additions easier, keep different features manageable when they are based on more generic solutions, and optimize whole system. Anyone who has developed games knows that the development involves lots of prototyping, and quick ad hoc solutions. That is a necessary evil, because it will quickly show whether the feature works or not. But then, when it seems to work, you should tidy up you implementation.
But this process gave an opportunity to implement everything better, and develop features that fit together, in a way that there is a comprehensive system behind everything that happens in the game. During this time I redesigned the set or parameters that define surface types, object types, physics materials and trace channels, so that they support many features that depend on that data - features like
Custom navigation and path finding
Procedural dynamic environments
I cannot emphasise enough how important it is to understand thoroughly how the whole collision system, trace channels, object channels and profiles work. If you design them well in the beginning, it will save lots of time later and it will make it easier to manage how your actors interact.
When that groundwork was done, I started the work on generic creature framework, that would support animals with relatively simple behavior plus robots and NPCs with more complex behavior. Main idea in this framework is to generalize creatures, their behavior, movement, animations etc in data oriented way, so that the creature is like a collection of parameters, animations and visual assets. Creatures can be customized individually with configurable parameters, but they share the code that controls their actions. This will make it faster to add new creatures, since we only have to define parameters and certain animations.
Since these creatures can move anywhere - on ground, indoors, on water, under water, in air and climb trees etc - I had to develop a custom navigation and movement system. Normal navmesh has many problems, and updating a dynamic navmesh can be a hit to performance. So, I developed a system that analyses the environment and creates paths. This has numerous advantages. One of them is that the path can go anywhere, even under the landscape. Path can lead up to the tree top. I can control animations based on analysed path, e.g. character can jump, crouch and crawl when necessary.
Somewhere between all this I also made a procedural generator for sci-fi bases which could generate multilevel structures that conformed to ground. It uses component based approach and several algorithms which control the overall architecture.
After this I put some focus on vehicles. Unreal Engine uses PhysX, and its car physics have some quirks which made vehicles quite unstable. Since our idea is that also NPCs could drive vehicles and vehicles could be even self-driving, it was a serious problem. But I developed some corrections to car physics, and now those vehicles are extremely stable. While I was doing that, I also developed jump jets for the car (because I am a fan of Knight Rider). After that I had to develop towing system for those vehicles, and grappling hook with winching capability.
Since the car was now stable, I developed a self-driving AI system for vehicles, with visual environment analysis, navigation, path finding and obstacle avoidance. It uses similar approach as the creature navigation I developed earlier - it does not use nav mesh - but is adjusted to fast speed, too. After that I programmed NPCs to drive the car themselves, and made a driver-passenger system, where player can swap places with NPCs. Player can drive the car, or sit as a passenger while NPC drives the car, of car can drive itself (with passengers or not), or player can steer car remotely.
I also started the work on climbing system for player, NPCs and other creatures, which includes not only free climbing, but rope assisted climbing with rappelling. Again this was something that I developed and tested in a separate sandbox project, and then imported that solution into Planetrism.
Planetrism is a game, where gameplay is very community oriented. Player has to manage the colony, all non-player characters and robots. Game world itself has several other creatures which can live in packs. So there is a need for general communication system that covers all possible methods of communication ranging from simple gestures and olfactory signals to complex dialogue of humans.
At the end of the year I also put some work on a procedural environment generator, which makes dynamic biomes. It is intended to complement those tools already existing in Unreal Engine, not to replace them. This generator produces environments with dynamic ecosystem, resources you can harvest, vegetation that can grow, seed new samples and expand. Trees can fall, wither and die. Mushrooms and other vegetation can spread and grow on anywhere on horizontal and vertical surfaces, on any object. Water level on lakes can rise or sink, and vegetation adapts to situation. Everything is linked to game mechanics.
Overall, it was quite interesting year, and I learned many new things while inventing creative ways to make Unreal Engine do what I wanted it to do. My approach is such that I experiment a lot, make several prototypes, test and iterate. Unreal Engine makes it all very easy and enjoyable. Will I continue to write these newsletters? I really don’t know. It depends on whether I have some extra time or not.