How did the idea for Zombie Kebab VR come about?

On August 15, 2012, at Gamescom in Cologne, I saw Fruit Ninja VR.
I thought: cool, but what’s cooler than fruit? Kebab! And what instead of ninjas? ZOMBIE! Shivers went through me, and I haven’t been able to free myself from that thought since.

What did the first steps of the project look like?

The idea was simple, but the vision evolved over the years. At first it was to be a mobile game — in those years kitchen time-management titles, where you prepared orders on time, were still quite popular. I wanted to add zombies, which were at their peak in 2012. This concept helped me get a job in mobile games. I thought I would quickly learn how to make games and release my project — a combination of Cooking Fever and Into the Dead. Two mobile prototypes were created, but the feedback was clear: shooting zombies on a phone is mediocre. Limitations in control precision, a small workspace and a stationary camera meant that it just didn’t work.

What was the biggest breakthrough?

One day when I was collecting feedback after another redesign of mobile screens I heard: “Nah… not like that. Make it so the players feel they’re there.” Context was missing and the game lacked character. I started collecting references, taking pictures of the TV when a frame suited me.
I could see it in my head: 1970s Brooklyn, 1990s Gdansk at night, industrial districts, graffiti, street trash, dark alleys. But how to embed it in the game?

The breakthrough came when I discovered Tilt Brush.
I could quickly sketch the world around me in a natural way. One night, after several hours of drawing, I suddenly took off the headset, convinced there was a zombie behind me. I felt there was no turning back — I knew that fear had to find its way into the game.

Were there moments of doubt?

Sure, there were moments of doubt. Friends would ask: “Yo Dziki, how is Zombie Kebab?” I did not know myself: “What platform is this game coming out on?”, “Is this kebab made of zombies?”, “Why are you shooting them? — They just want to eat kebab at 4 a.m.”. When I had no answers to these questions, the project seemed absurd. Then VR opened my eyes. I just started creating this world around me, and magically it all started making sense to me. As I immersed myself in this place I realized that the Zombies don’t come for kebabs — zombies come to kill you, and you cook for people who have buried themselves in their houses — they’re afraid to come out because zombies are prowling around. You have a gun, a car, and people to feed. Sometimes an armed courier will come to pick up orders, sometimes a drone will come, and if you think hard enough — you’ll figure out how to turn on the ordering system on a broken TV.

How has TikTok influenced the project?

In 2020, I started uploading short snippets of gameplay to TikTok. No promotion, no trends. And suddenly? Tens — hundreds of thousands of views. Finally, measurable interest. That gave me a signal: the project was alive.

What was it like to learn the necessary skills?

Learning what turned out to be necessary was not obvious. It’s not always clear what you need to learn. Tools: Inkscape, Photoshop, Blender, Unity, programming basics. But the key is to combine them consciously. You want a house in the game? You build a model in Blender, texture it in Photoshop, set up the materials in Unity, and look at it on the headset. That’s how I built my workflow.

What surprised you most about the game’s reception?

TikTok showed me what people were interested in — not the art, but the gameplay. So I started sharing the development progress. The videos sometimes got a second life, most recently our footage with a truncated logo — signed “Armenian Fast Food Simulator” — is circulating on facebook a year after its release on TikTok. People sometimes ask in the comments: “What game is this?” And fortunately, an answer appears: It’s ZOMBIE KEBAB VR!

What advice would you give to people who want to make their own game?

Creating a game is not just a matter of wanting to, it is a matter of regular, deliberate action. It doesn’t matter how long it takes to make a game. Even if it takes 10+ years, do what you feel, work at your own pace, iterate to your heart’s content. If you have the space to work intensely, get a team together, set up a repository, organize a channel on Discord, and make decisions. Make commits, post updates, and share your progress on social media, because when you see that someone cares, you know it makes sense, and the work moves forward somehow. Progress, however small, is more important than spectacular results achieved through superhuman effort. And remember:

A goal without a plan, deadlines, and regular work is just a fantasy.

So when will the game be available?

As someone once said — it’s coming when it’s ready.

My very first gigs in the IT world were designing websites. I remember when Microsoft Front Page was introduced to the market in the mysterious aura of WYSIWYG technology. The term ‘What You See is What You Get’ had already been circulating in IT since the mid-1970s when printing technology first started allowing content to be edited in a form that resembles its appearance when printed as a finished product. Some 20 years later the same idea was revived in web design in Microsoft’s advertising campaigns.

OK boomer

Year 2024 is as far away from 1997 as 1997 was from 1970. So naturally I thought maybe now all you need to do is to give ChatGPT an image and it would write the code for your website? I tried and this is what I got:

I tried several AI tools as well but nothing seemed to be able to painlessly translate the image to a working code. What now? I looked at fiverr — maybe if I spend a few bucks on a gig I could get it done in one day?

I was convinced that it can be done faster and cheaper than that. So I went to see what are some other options. I remember WIX.com — they used to have a free plan that allowed you to quickly design webpages, they also added some AI tools on top of that recently, and if all I wanted to do was to customize a pre-made template I would have it ready in no time.
However, that wasn’t the case — I had the layout already designed. I felt like I was almost there. Just one more step…

But let’s start from the begining.

The creative process

First, I explored some concepts with ChatGPT and dall-e and put them on a Miro board to have an overview of possibilities:

Then I picked the elements that made sense for me and roughly placed them on a dirty mockup:

After that I refined every element, added in-game assets and real testimonials from the feedback we got on social media.

But what to do with them? And how to make sure the layout is responsive, mobile friendly etc? And then I reminded myself about Canva. All my non-artist friends who used it were amazed how easy it was to create beautiful and shippable content in a matter of minutes. So I decided to give it a try.

I simply placed all the elements on an empty page, used layers, and set the largest image as the background.

Then I grouped elements like text and image together:

and aligned elements to each other and to the page itself, made sure it looked ok on different screens:

published it for free at https://zombiekebab.my.canva.site/sign-up, and asked my friends to visit it and tell me if it displays correctly. It did.

The last step was to link my website to this address. We could be paying a monthly fee for Canva premium but as an indie studio we cut all expenses by a rule of thumb. So naturally, I asked ChatGPT how to redirect the traffic from zombiekebab.com to zombiekebab.my.canva.site/sign-up the easiest way. And I received this HTML snippet:

And that’s it!

For the first time since creating the domain in 2013–08–15 it was live. More importantly, it features a prominent button that allows the players to sign up for the upcoming release. The waiting list is growing quickly, and we’ll soon be sending out the newsletter as Valentine’s Day approaches. And what’s better than a kebab on Valentine’s Day?

P.S. Feel free to visit www.zombiekebab.com and let me know if it does not display correctly for you :)

Game designers continually seek tools and methods that can enhance their games’ mechanics, story progression, and decision-making. While neural networks and AI have gained significant traction, mathematical models like graphs and Markov Chains offer unique advantages for designing dynamic, responsive, and unpredictable game environments.

In this article, we’ll journey from understanding a couple of fundamental concepts to implementing Markov Chains, allowing game designers to harness the power of probability and statistics in game design.

Ancient Philosophical Puzzles and Modern Stochastics

Andrey Markov, a Russian mathematician, introduced Markov chains in the early 20th century. Before Markov’s, the explicit concept of a Markov chain as we understand it today did not exist. Despite this, ancient holds numerous examples of preliminary considerations on stochastics, laying some groundwork for future explorations in the realm of probability.

The concept of probability can be traced back to ancient civilizations’ games of chance. Ancient Greeks, including philosophers like Plato and Aristotle, discussed randomness and determinism. However, their discussions were more philosophical and not mathematical in the way modern probability theory is. Plato believed in an inherently ordered universe where randomness was but an illusion. In contrast, Aristotle preached the existence of genuine random events in the universe.

The word “stochastic”, rooted in the Greek term “στόχος” for “aim”, brings forth an intriguing connection, especially in the world of

precision and accuracy.

In any endeavor the distinction between the two is paramount. Let’s consider the mechanics of aiming and shooting. Every competitive player knows that when your shots are both accurate and precise, you’re not just playing the game — you’re dominating it.

To put it in game terms, imagine every shot you take in a first-person shooter game as a data point. There are four targets, each representing a different combination of accuracy and precision. Accuracy refers to how close your shots are to the target’s center, while precision refers to how close your shots are to each other.

• Low Accuracy, Low Precision: Your shots are scattered, indicating inconsistency and unpredictability in gameplay.
• Low Accuracy, High Precision: Your shots consistently hit the same wrong spot, suggesting a systematic error or bias in the game’s aiming mechanics.
• High Accuracy, Low Precision: Your shots hit around the target center but are widely spaced, implying a correct aim but high variability in execution or outcome.
• High Accuracy, High Precision: Your shots are tightly grouped at the target’s center, the ideal state for a player seeking to master the game.

Each action in a game, much like the ancient games of chance, can be seen as a part of a stochastic process, a sequence of events influenced by random variables.

State machine

Aiming and shooting in a game can be modeled as a Markov chain, where each shot represents a state transition. The probabilities of hitting or missing the target could depend on in-game factors such as the player’s skill, weapon accuracy, or even the game’s inherent randomness.

So what is the missing link between these two graphs?

The answer is: literature!

Andrey Markov’s theory was indeed influenced by his interest in the statistical patterns of letters in literature. He sought to prove the Law of Large Numbers for dependent events, as opposed to the then-common application to independent events like coin tosses.

Markov was intrigued by the work of other mathematicians who were analyzing the frequency of vowels and consonants in Russian poetry. They treated the letters in text as a sequence of independent events, but Markov suspected that the letters were not independent — that the appearance of a certain letter could depend on the letters that came before it.

This was a departure from existing statistical methods which typically assumed that each event (or letter, in this case) occurred independently of others.

Markov’s analysis involved creating chains where each letter was a state. He then examined how the sequence of letters transitioned from one state to another. For example, if the letter ‘a’ appeared, what was the probability that it would be followed by a vowel versus a consonant?

The culmination of Markov’s work, opened the door to further advancements in understanding sequences and probabilities. One significant extension of this concept is the Hidden Markov Model (HMM).

In an HMM, we observe a series of outputs generated by a sequence of hidden states, and the model aims to infer the hidden states based on the observable outputs. They are well-suited for modeling sequential data with temporal dependencies. HMMs are trained using algorithms like the Baum-Welch algorithm for unsupervised learning. They can be used in cases where labeled data is limited or unavailable.

How to apply Markov chains in game design?

In the realm of game design, applying Markov chains can significantly enhance the dynamism and realism of in-game AI behavior. By integrating these probabilistic models, designers can create characters that react in varied and unpredictable ways, providing a richer gaming experience.

State Machine: A Markov Chain in Action

Let’s see how Markov chains can be utilized, particularly within the context of our game “Zombie Kebab VR”.

Consider the behavior of a zombie in a survival horror game. This list of states represent a set of zombie’s potential actions:

• Idle: calm state, unaware of the player’s presence.
• Wandering: aimlessly moving until something catches its attention.
• Chasing: As in sensing its prey, it engages in pursuit upon the player’s detection.
• Attacking: In close combat with the player.
• Dying: The final state leading to total decay.

The transitions between these states are influenced by game-world stimuli — much like the way ancient philosophers believed external forces influenced the roll of dice or the flight of an arrow. For example, the proximity of the player can affect whether the zombie starts wandering or chasing. Tweak the transition probabilities, and you alter the tension and pace of the game. Add more enemies and time pressure to increase difficulty.

The result should be a gameplay mechanic that feels organic, as if having a set of natural laws, while being fueled by a probabilistic model.

If you are interested how do we implement the opponent’s behaviors in our upcoming VR title, visit www.zombiekebab.com

It’s 2024, and using a computer now feels like stepping into the special effects of the movies we watched as kids. We were promised to be able to chat with our computers, zoom-in into low-res images and see all the details in one click etc. I remember looking at my C-64 hoping one day computers will be powerful enough to actually perform this kind of magic, while twisting the screwdriver in a cassette player in order to load the Great Giana Sisters from a ferro-magnetic bootleg tape. Fast-forward 30 something years:

To be honest, conversing with ChatGPT as my clients once did when I was a graphic designer yields surprisingly good results. They’re not perfect at first, as this example shows:

My first reaction was “OK this button actually IS uber-clickable but not really useful for what I was working on”. I just needed a button that “looks better” i.e. has the same shape, proportions, colors, fonts… yes sounds like useful context to begin with. But it doesn’t have to be. I was sure we can still get there in a very few prompts. What did the trick was adding the following information:

- it is an asset on a webpage it needs to be roughly the same size shape and bgr is white,
- make sure that the shape of the button is rectangular, wide and short enough to put “SIGN UP” in one line

Using it, ChatGPT redacted the prompt :

A realistic-looking rectangular button with a smooth gradient from light orange to deep red, and the text ‘SIGN UP’ in bold, white, sans-serif font across one line. The button has a subtle, realistic texture suggesting a semi-gloss finish and is designed with slight shadowing to appear clickable against a white webpage background. The shape is a wide rectangle, ensuring the text fits on one line without breaks, size 1792x256.

and used DALL-E to generate:

All this happened roughly in the amount of time that 10 years ago I would use to start my PC, open Blender and delete the default cube. But is this asset any good for prototyping? Almost.

Next, I needed to cut it out from the background and isolate the shadow. And for this I went super old-school and used Adobe Photoshop. Some 9 months ago they have introduced the “Object Selection Tool” — it should handle a simple shape like this, right?

It is just a rectangle with rounded corners and Adobe always seemed to me like an expert on math behind shapes like these but I think, judging by the results, these are still two separate technologies :D

So yes, there is still some space for manual work to be done. You can define a vector shape, use it as a mask, invert it, select the color range of the shadow and cut it out. This way you will have two elements and a transparent background. I would say it’s enough to use it on a rough mockup. There are also some typical AI-hallucinated artifacts like shapes that make very little sense from a typographic point of view. But again it’s nothing that a good old stamp and brush won’t fix:

Now this finally looks like a job for a human designer! One could spend at least a couple of hours making the shape look spotless. Fixing the lights, shadows, geometry and gradients until it looks perfect. But do we really need it? Depending on the context we could hold a series of meetings to discuss what to do with it or confirm what works better via AB tests, but since we’re a small indie studio, at this stage all this activities are out of scope.

…and it still looks better than just a flat shape done in Miro.

Wait what? Using Miro for UX?

Some of you may react allergic to creating mock-up screens in Miro instead of preparing them in Figma, but when the design is relatively simple, there are not many elements and all you need is some basic layout — I would argue that Miro + Photoshop + basic HTML and CSS is enough. And if you want to have responsive design or parallax effects, I think you can just ask ChatGPT to write some custom .js Would I bet my last penny on it? Definitely not. Would I write an another article if it looks decent enough? Absolutely!

(EDIT: see https://medium.com/@mdzikowski/create-responsive-websites-with-chatgpt-miro-and-canva-in-minutes-631ae9452c83 for the follow-up)

Conclusion

So here’s the thing: even as AIs like ChatGPT and DALL-E make design faster, we’re the ones who make sure that our design doesn’t just look good, it’s about making it feel right. I don’t think we’re being replaced — we’re evolving. As designers, our role is to blend AI efficiency with our creative instincts. We’re adding soul to the silicon. And that’s something AI can’t replicate.

Traditionally, capturing high-quality motion capture data for VR games has been a complex and expensive process, requiring specialized equipment and software. This technique could be an invaluable asset, especially for smaller teams or independent developers who might not have the budget for high-end motion capture technology.

Having some extra time during the winter break, we wanted to see if we can prototype some custom zombie animations for our project. With just a couple of hours at hand the goal was to minimize the effort while working on adding states to the zombie characters. Why do we even need states — one may ask. The simple answer could be:

We add character states because changing them is what enables us to create meaningful situations in the gameplay. Let’s take the example of a Zombie itself. Is it dead or alive? Defining states can be tricky but also is very useful from a game designer’s perspective.

So how to add meaning to a walking Zombie? For example, you could assign a different purpose to it’s movement, let’s say it walks not just for the sake of walking but it walks with a goal to kill the player. That *should* influence the game dynamics, right?

A walk is at least two steps.

Our initial idea was to use two tools: https://vision.rokoko.com/ and https://www.youtube.com/@Cascadeur in order to capture a video from a phone, clean it with an AI-tool and then use it in Unity Engine as a 3d animation for our Zombie. It sounds like a crazy fast animation development cycle but are we there yet?

At the current stage our workflow involves:

• capturing short video clips on a Samsung SM-S918
• uploading them to https://vision.rokoko.com/
• cleaning keyframes in Blender
• and exporting fbx animations to Unity.

We decided to go with this workflow because so far it looks like a well balanced approach between joining the ubiquitous AI automation craze and adding enough human touch to respect of the tradition of crafting video games, but most importantly we chose it because we were able to create some in-game assets.

The prototype

Our initial motion capturing session resulted in having recorded around 20 clips that could potentially be used as hit reactions or walking cycles:

But rushing the process without making sure the initial settings are correct feels a bit like gambling with the industry’s good practices. So in order to mitigate the risk of not delivering the assets within a rather radically short timeframe of a couple of hours we needed to refine the process and reiterate.

It s always “step i+1”

When trying to achieve an ambitious goal like “have zombie walking-cycle ASAP working in the game” we wanted to make sure that achieving our goal is possible to a measurable degree. We knew that anything else than a seamless integration of all elements in the pipeline could potentially compromise our goal. Processing the initial sample recordings revealed only one issue, but interestingly enough, quite a severe one:

Our assumption was that the distortion is caused by the optical system using a wide lens. So as this problem was adding extra complexity by requiring fixing not only the positions but also the rotations of the bones during the cleaning stage and we didn’t know of any auto-magical AI tools that would do it in an instant, we needed to reiterate the approach. Again.

Step 02

Compared to the initial calibration test, in the second experiment we were using a larger distance (5 steps instead of 3) and the same camera: 10MP 1/3.52″ sensor, 1.12 μm pixels, f/2.4-aperture

Additionally in this setting we have captured footage with the steps made towards the camera as well as in parallel to it:

In our experiment walking towards the camera resulted in missing data:

But luckily the second approach yielded much better results:

Conclusion

Creating character animation for games at home using nothing but your phone and free AI tools looks very promising in the final weeks of the year 2023. Of course this is not a recipe to get a AAA quality asset in under 5 minutes… yet. But it is worth noting that the motion-capture technology has recently become much more accessible than ever allowing indie designers to tell their stories even easier than before.

Join the Horde!

If you would like to see the animations implemented in the game — follow the development of “Zombie Kebab” on our TikTok account https://www.tiktok.com/@zombiekebab and in case you would like to get the early access to our game, please feel free to contact us via this form.

A Viral Sensation Capturing the Heart of the City’s Late-Night Charm

In a world where indie games often struggle to make a mark, “Zombie Kebab VR” stands out as a viral phenomenon. We’re focusing on the vibrant, sometimes chaotic energy of city life at 4 AM, reimagined in a post-apocalyptic world. Our TikTok video unveiling pre-alpha footage captured a staggering 1 million views just a couple of days after posting it, with reposts on instagram YT and vk with the most notable coverage from @makelifeharder. (total organic reach estimated 50M views in 30 days).

https://www.tiktok.com/@zombiekebab/video/7295935810728119584

The Power of Players’ Imagination

Players have enthusiastically related “Zombie Kebab VR” to real-life hardcore urban experiences:

Cities like Paris, Berlin, Manchester, Ankara, New York, Vancouver and many others were mentioned, reflecting the game’s universal appeal. This connection brings a sense of familiarity and humor to the zombie survival genre, turning the act of serving shoarma (a.k.a. “Döner”, “gyros”, “taco al pastor”) in the midst of a post-apocalyptic chaos into a relatable fantasy.

One of the most heartwarming aspects of this journey has been the comments from our community. Phrases like “Game of the Year” have popped up more often than we could have ever imagined. While we’re flattered by such high praise, we see it as a reflection of the fun and excitement we aim to deliver through “Zombie Kebab VR.” It’s a reminder of the humble promise we make with this game to the gaming world.

As a small indie team driven by passion and creativity, we are thrilled by the positive reception of “Zombie Kebab VR.

This game is more than just an entertainment piece; it’s a vivid demonstration of how a unique idea can resonate with a global audience.

Join the Horde: Open Beta Coming Soon!

We’re excited to take this journey to the next level and invite you to be a part of it. The open beta for “Zombie Kebab VR” is just around the corner, and we encourage you to sign up via our Google Form to stay updated. This is your chance to be among the first to experience this one-of-a-kind VR adventure, a game that’s as much about community feedback and engagement as it is about immersive gameplay.

Stay Connected

Don’t miss out on the latest from “Zombie Kebab VR” — follow us on TikTok.

To kick off the series, let’s start with the foundation of neural networks:

The McCulloch-Pitts Neuron. A Simple Building Block

The idea behind the designers of the first computer neural networks was to use an element that takes some basic unit of data, modifies it, and then passes it on. When many such elements are combined, networks are formed that modify the input data in some specific way.

Demystifying the Mathematical Symbols

The mathematical equation for the McCulloch-Pitts neuron might seem a bit overwhelming at first. But fear not! We’ll break down these math symbols into simpler components and make it more approachable.

s = Σ(xᵢ * wᵢ) for i=1 to n

Let’s decipher each symbol:

• s: The weighted sum of the inputs. We need the result to use it in the activation function f(s). We'll compare this value to a threshold to see if the neuron "fires" (outputs y=1) or stays inactive (outputs y=0).
• Σ: Sigma, the uppercase Greek letter. It means that we’ll be summing up the products of the input values (xᵢ) and their corresponding weights (wᵢ) for all inputs in the range specified.
• xᵢ : This is the input value at position i.
• wᵢ : The weight associated with the input value at position i.
• i=1 to n: This sets the range of the summation, where i starts at 1 and goes up to n.

In simpler terms, the equation calculates the weighted sum s by multiplying each input value xᵢ by its corresponding weight wᵢ . The resulting weighted sum s is then used in the activation function f(s) to determine the output of the neuron (y) by comparing it to the threshold.

Here’s an example of how this equation could be applied to a neuron with 3 inputs (n = 3):

inputs = [x₁, x₂, x₃]
weights = [w₁, w₂, w₃]
s = (x₁ * w₁) + (x₂ * w₂) + … (xₙ * wₙ)

Neurons in a spreadsheet

As game designers, you might spend a lot of time balancing games in tools like Microsoft Excel or Google Sheets. So, let’s make the weighted sum calculation a bit more relatable:

Now that we have our weighted sum, let’s apply the activation function and threshold in Google Sheets to determine the output of the neuron.

For those of you who might be curious about the inner workings of the weighted sum, we can explore it in more detail using some Python code to visualize the concept. Don’t worry if you’re not a coder; this is just to help clarify the idea.

Calculating the weighted sum using Python’s list comprehensions

def mcculloch_pitts_neuron(inputs, weights, threshold):
 
    # Compute the weighted sum of the inputs
    weighted_sum = sum([input_val * weight for input_val, weight in zip(inputs, weights)])
    
    # Apply the threshold function
    return 1 if weighted_sum >= threshold else 0

# Example usage
inputs = [1, 0, 1]
weights = [1, -1, 1]
threshold = 2

output = mcculloch_pitts_neuron(inputs, weights, threshold)
print(f"The output of the McCulloch-Pitts neuron is: {output}")

This code defines a mcculloch_pitts_neuron function that takes binary input values (0 or 1), weights corresponding to the input values, and a threshold as input arguments. It computes the weighted sum of the inputs and returns the output (0 or 1) based on whether the weighted sum is greater than or equal to the threshold. In the example provided, the neuron's output will be 1.

The key part of this implementation is calculating the weighted sum of the inputs. This piece of code does the job:

sum([input_val * weight for input_val, weight in zip(inputs, weights)])

Here’s how it works:

1. zip(inputs, weights) combines the inputs and weights lists element-wise into pairs, creating an iterable of tuples:
   [(1, 1), (0, -1), (1, 1)]
2. The list comprehension [input_val * weight for input_val, weight in zip(inputs, weights)] multiplies each input value with its corresponding weight and creates a new list.
   [1 * 1, 0 * (-1), 1 * 1] = [1, 0, 1]
3. sum() calculates the sum of the elements in the list, which represents the weighted sum of the inputs.
   1 + 0 + 1 = 2
4. finally, the binary threshold function return 1 if weighted_sum >= threshold else 0 returns 1 if the weighted_sum is greater than or equal to the threshold, and returns 0 otherwise.

⚠️ REMARK: This is a simple way to calculate the weighted sum using Python's list comprehensions and built-in functions. It works well for small to moderately-sized datasets. However, for larger datasets, using a more optimized approach, such as NumPy, would be more efficient and faster in processing large arrays of data. Here's an example:

import numpy as np

inputs = np.array([...])
weights = np.array([...])

weighted_sum = np.dot(inputs, weights)

Both methods will have a linear time complexity O(n), but the NumPy version is likely to be faster in practice due to the optimized implementation of the dot function, which takes advantage of low-level optimizations and the efficiency of the underlying C/C++ code especially when dealing with large datasets.

🎮Using a McCulloch-Pitts neuron to model decision-making processes

Now that we have a good understanding of the weighted sum, let’s take it a step further and see how we can use it in our game.

Imagine you’re designing a game character that can perform an action only when certain conditions are met. For example, a character might attack if it has enough energy and is close to a target.

Consider two binary inputs:

1. Energy Status (1 if the character has enough energy, 0 if not)
2. Proximity Status (1 if the character is close enough to the target, 0 if not)

We can model this decision-making process using a McCulloch-Pitts neuron with these inputs, assigning each input a weight of 1. We’ll set the threshold value to 2, which means the neuron will activate only when the sum of the inputs, multiplied by their weights, is equal to or greater than the threshold.

Here’s the implementation of this decision-making process:

def should_attack(energy_status, proximity_status):
    inputs = [energy_status, proximity_status]
    weights = [1, 1]
    threshold = 2

    return mcculloch_pitts_neuron(inputs, weights, threshold)

# Example usage
energy_status = 1  # Character has enough energy
proximity_status = 1  # Character is close enough to the target

if should_attack(energy_status, proximity_status):
    print("The character will attack!")
else:
    print("The character will not attack.")

Some of you may notice that in this specific example, the McCulloch-Pitts neuron essentially behaves like an AND gate, where both conditions need to be met for the neuron to activate.

However, by adjusting the weights and threshold, you can create more complex decision-making processes that incorporate different levels of importance for each condition.

For instance, consider a scenario where a character should be more likely to attack if they have enough energy, but proximity to the target is a less important factor. In this case, you could assign a higher weight to the energy status input and a lower weight to the proximity status input.

To achieve this, we need to assign weights to each input that reflect their importance in the decision-making process. There are several ways to find the best weights: trial-and-error, experimenting with different values, or using machine learning techniques, but while a single McCulloch-Pitts neuron can only represent simple binary decisions, a neural network can learn complex patterns and relationships by connecting multiple neurons together.

Creating a neural network

Creating a neural network from neurons like the McCulloch-Pitts model involves connecting multiple neurons together in layers, where the output of one neuron serves as input to another neuron. Neural networks can learn to make decisions and adapt their behavior based on experience by adjusting the weights of the connections between neurons.

However, the McCulloch-Pitts neuron model is quite simplistic, with binary inputs and outputs, and no built-in learning mechanism. Modern neural networks typically use more advanced neuron models, like the perceptron or the artificial neuron with a continuous activation function (e.g., sigmoid or ReLU).

To create and train a neural network in a game context, you would typically follow these steps:

1. Define the network architecture: Design the structure of the neural network, including the number of layers and the number of neurons in each layer. The input layer should have as many neurons as there are input features (e.g., character health, distance to target), while the output layer should have as many neurons as there are possible actions or decisions to make (e.g., attack, defend, retreat).
2. Initialize the weights: Assign random initial values to the weights of the connections between neurons. These values will be adjusted during the training process.
3. Define the learning algorithm: Choose a learning algorithm to update the weights of the connections based on the error between the network’s output and the desired output. Common learning algorithms include gradient descent, backpropagation, and various optimization techniques like stochastic gradient descent, Adam, and RMSprop.
4. Collect training data: Gather a dataset of game states and the corresponding correct actions or decisions. This data can be collected from expert gameplay, human demonstrations, or generated through reinforcement learning techniques.
5. Train the network: Feed the training data into the network, calculate the error between the network’s output and the desired output, and update the weights using the chosen learning algorithm. Repeat this process for multiple iterations (epochs) until the network converges to a satisfactory performance level.
6. Evaluate and fine-tune: Test the network’s performance on new, unseen game states to ensure it generalizes well. If necessary, fine-tune the network by adjusting its architecture, learning algorithm, or training data.
7. Integrate the trained network into the game: Once the network is trained and performs well, integrate it into your game as part of the character’s AI, where it can make decisions based on the game state.

Conclusion

In this article, we’ve explored the foundational concept of the McCulloch-Pitts neuron, which forms the basis of neural networks. We’ve learned how these simple binary threshold models can be used to represent decision-making processes in game characters. We’ve also delved into the mathematics behind weighted sums and activation functions, and demonstrated how to implement these concepts using Python and Google Sheets.