Don’t worry, it’s not rocket science \ud83d\ude09<\/p>\n
Some theory<\/strong><\/p>\n All video games have gameplay mechanics based on logic. A game is “a set of story driven goals to achieve”<\/em> from a programmer’s perspective.<\/p>\n When you open a chest, solve a puzzle or kill an enemy, you are actually triggering a logic unit<\/strong> that is predefined within the game code. Depending on game’s technical requirements and gameplay complexity, there can be thousands of these units forming a web of logic units<\/strong>.<\/p>\n Game programmers tend to use graph\u00a0theory<\/a> for defining and coding logic units. Each unit\u00a0is symbolized with a simple geometric shape. A box, a circle, anything… And these units are connected to each other with links.<\/p>\n Behaviour Analysis<\/strong><\/p>\n A node graph architecture is almost <\/i>identical to an electronic circuit<\/a>. When you start executing a node graph code, you are actually branching from one component (node, in our case) to an another by the rules you’ve set for the logic units, just like electric current<\/a> flowing from a resistor to a capacitor. And, as you can guess, this type of signal flow is 100% linear.<\/p>\n When the player accomplishes a task, the node related to that event will be “expired”<\/em>. In other words, it will be dead. Expired nodes cannot be resurrected. Once they’re done, they will be ignored (skipped) during code execution, forever. – Which is unlikely in electronics! An electronic component, such as a resistor, a diode, etc. cannot be conditionally turned on\/off.<\/p>\n Back to 2002 for a “classic” implementation: Flagger<\/strong><\/p>\n During the “Culpa Innata”<\/em><\/a> development sessions, we precisely knew that we needed a node graph architecture for handling game’s complex execution flow. Many discussions were held on the method of implementation. All members of the core<\/em> management & development team were expert electric\/electronics engineers with no experience in video game\u00a0production [Reference]<\/a><\/sup>, but me! As a video game programmer, my perspective towards node graph theory was naturally <\/i>very different, contrary to their classical approaches. I wasn’t thinking in terms of voltage, current, etc., but focused\u00a0on just one thing: optimized code execution.<\/p>\n Thanks to my Zilog Z80<\/a> and Motorola 68000<\/a> assembly language programming background, I offered the term “Flag”<\/em> for the base logic unit (node), and teamed up with Mr. Mete Balc\u0131 for 3 weeks. In December 2002, we developed a tool called “Flagger”<\/em>.<\/p>\n Pros and Cons<\/strong><\/p>\n Flagger<\/em>\u00a0was a C++ code generator with a very handy visual interface similar to UE4’s current Blueprint approach. Using Flagger<\/em>, we were able to add nodes, connect them to each other, program the logic behind the nodes\/links, and even take printout of the whole node graph scenario. When the visual logic design process was over, it was just a matter of selecting “Generate C++ code”<\/em> from the menu, and source code was generated within minutes.<\/p>\n Over\u00a0the following years, Flagger<\/em> evolved into a more sophisticated development tool capable of handling various scenarios. Although it was a very handy tool and saved many hours during “Culpa Innata”<\/em> sessions, there were a few problems with the classical<\/i> node graph theory that the implementation was based on;<\/span><\/p>\n A Modern Approach: 3-bit Worker!<\/strong><\/p>\n 13 years later, I have once again found an opportunity to dive into node graph theory, and just completed implementing a new architecture for my latest video game development project. Unlike Flagger<\/em>, it is something extraordinary<\/em>! It is very… atypical<\/em>, unconventional<\/em>, unorthodox<\/em>… Well, whatever… You got it \ud83d\ude09<\/p>\n First of all, it has nothing to do with classical electric\/electronic circuit theory. This time, I’m on my own, and approaching the problem as a software engineer. Everything I designed\/coded is based on game requirement specifications. In other words, it is implemented with “practical usage” in mind.<\/p>\n Any drawbacks?<\/strong><\/p>\n Sure… Due to complexity of comprehending “a set of non-linearly<\/strong> linked time dependent linear<\/strong> nodes”<\/em>, debugging can be a nightmare. As always, designing simplified and organized logic sets reduces potential problems. – I keep\u00a0my\u00a0logic\u00a0sets\u00a0neat and tidy \ud83d\ude09<\/p>\n So, what’s next?<\/strong><\/p>\n Well, to be honest, since all theoretical stuff is done, I’ll switch to game content development. I am quite sure that I’ll keep on adding\/removing things to my 3-bit node graph architecture. I will keep on improving it while preserving its simplicity<\/strong>, for sure.<\/p>\n “It is vain to do with more what can be done with less.” – (William of Ockham)<\/a><\/em><\/p>\n","protected":false},"excerpt":{"rendered":" Speaking of my latest video game development project, yet an another milestone achieved. – Quite a tough one, indeed! But first, please allow me to focus on some of the very basic mathematical logic definitions heavily used in software engineering, so that we can clearly understand what’s going on under the hood of a decent … Continue reading 3-bit Node Graph Architecture for Next-Gen Game Development<\/span> ![\"\"](\"http:\/\/mertboru.com\/wp-content\/uploads\/2015\/03\/nodegraph_sample.png\")
<\/p>\n![\"\"](\"http:\/\/mertboru.com\/wp-content\/uploads\/2015\/03\/z.webbullet_dashed.png\")
\u00a0\u00a0“Logic units”<\/strong><\/em> (nodes) represent tasks that the player will perform.<\/p>\n\u00a0\u00a0“Links”<\/strong><\/em> (lines) represent the relationship between the logic units.<\/p>\n![\"\"](\"http:\/\/mertboru.com\/wp-content\/uploads\/2015\/03\/z.webbullet_endof.png\")
<\/p>\n\u00a0 Flags were single threaded.<\/strong> Only one node was allowed to execute at a time. No multi-threading.<\/p>\n\u00a0 Flags were expirable.<\/strong> When a task was done, related flag (node) was marked as “expired”, not deleted for the sake of logic integrity<\/span>.<\/span><\/p>\n\u00a0 Flags were not reusable.<\/strong> Once they were expired, there was no way of resurrecting them. – Inefficient memory usage, thanks to hundreds of expired nodes.<\/p>\n\u00a0 Flags were heavily loaded with variables.<\/strong> Too many dialogue related “customized” variables were defined for special cases (exceptions). –\u00a0Inefficient memory usage, once again.<\/p>\n\u00a0 Flag execution flow wasn’t well optimized<\/strong> because of node-tree search<\/a> algorithm. The more nodes we had, the longer it took to accomplish the search.<\/p>\n\u00a0 Flag execution was linear.<\/strong> When a node was expired, the graph code was first searching for related nodes and then retriggering the whole diagram from the beginning, like an electronic circuit simulator. – Well, that was\u00a0ideal for modeling a circuit, not for developing a video game!<\/p>\n<\/p>\n\u00a0\u00a0I have defined the basic logic unit<\/strong> (node), as a “worker”.<\/strong> – (Due to functional similarities, I simply borrowed this term from Web Workers<\/a>.)<\/em><\/p>\n\u00a0\u00a0A worker is a background task with adjustable priority<\/strong> settings. It\u00a0performs\/responds like a hardware interrupt<\/a>.<\/p>\n\u00a0 Each worker is multi-threaded.<\/strong><\/p>\n\u00a0\u00a0Depending on conditional requirements, a worker can expire and\/or live forever.<\/strong> If expired, it can be resurrected and\/or reinitialized, while preserving its previous state. So, a worker is a 100% reusable<\/span> node.<\/p>\n![\"\"](\"http:\/\/mertboru.com\/wp-content\/uploads\/2015\/03\/nodegraph_3bit_xxl.png\")
<\/p>\n\u00a0\u00a0Each worker uses only 3-bits!<\/strong> No additional variables, no references, nothing else. – (If necessary, a worker offers flexible architecture for additional variables. However, I find it totally unnecessary. 3-bits are more than enough!)<\/em><\/p>\n\u00a0\u00a0Workers are object oriented<\/a>.<\/strong>\u00a0They can easily be inherited<\/a>.<\/p>\n\u00a0\u00a0Inherited workers don’t need additional logic variables.<\/strong> All child workers share the same 3-bit information that they inherited from their parents!<\/p>\n\u00a0\u00a0Each worker has a time dependent linear<\/span> workflow.<\/strong> Just like a reel-to-reel tape recorder<\/a>, it can be played, paused, slowed down, accelerated, fast forwarded, rewinded, and stopped.<\/p>\n\u00a0\u00a0Workers can be non-linearly<\/span> linked<\/strong> to other Workers! Which means, node-tree search<\/a> algorithms are no more necessary. There is no “main loop” for executing nodes! Code execution is pre-cached for optimum performance.<\/p>\n\u00a0\u00a0Workers are optimized for event driven methodology.<\/strong> No matter how many concurrent active workers (threads) you have in the scene, there is practically no CPU overhead. Ideal for mobile scenarios.<\/p>\n\u00a0\u00a0Workers are managed by “Managers”.<\/strong> A Manager is inherited from base Worker node. So, any worker can be assigned as a Manager.<\/p>\n\u00a0\u00a0Workers can communicate with each other and access shared variables via Managers.<\/p>\n\u00a0\u00a0Whole architecture is 100% platform independent.<\/strong> For\u00a0a showcase, I’ve implemented it for Unreal Engine 4<\/a>\u00a0using C++ and Blueprints. It can easily be ported to other game engines;<\/span> such as Unity<\/a>, CryEngine<\/a>, etc.<\/span><\/p>\n\u00a0\u00a0And, most important of all, everything is meticulously tested. –\u00a0It’s working as of today \ud83d\ude42<\/p>\n![\"\"](\"http:\/\/mertboru.com\/wp-content\/uploads\/2015\/03\/nodegraph_WorkerManager_UE4_implementation-300x146.png\")
<\/a><\/p>\n<\/p>\n