ITHACA. A TOOL FOR INTEGRATING FUZZY LOGIC IN UNITY

In 1959 Arthur Lee Samuel introduced Artificial Intelligence into the world of video games, more specifically teaching a computer how to play the game of checkers [8]. Thereafter, other games were developed that included artificial intelligence, highlighting the video game Space Invaders in the 70s and Pac-Man in the 80s. In Space Invaders, complexity was added to the game by introducing hash functions that ”learned” from the player’s actions. The heart of the Pac-Man game is the behavior of the ghosts that are the player’s enemies, where each one has a different behavior [9] and it is controlled by a state machine [10]. In the 90s video games were booming due to the appearance of various consoles such as Gameboy, SNES or PS One. This expansion also produced the inclusion of more complex AI systems, with special mention to the Half-life video game in which it existed a cooperation between the enemies to kill the player [11]. In the 21st century AI has advanced considerably and its algorithms are capable of defeating a human player in games like Starcraft II [12, 13].

All these developments have in common, regardless of the AI that they integrated, the improvement of the user experience and for this objective AI is an outstanding candidate. AI can be used in different aspects of a video game as pathfinding, movement, making decision or learning [10], but probably the one that stands out the most is the one that controls the behavior of NPCs. The reason is because if the behavior of these elements is realistic and resembles the real world, the users will feel that he is not playing in an artificial and predefined world but in a world more similar to their own. In reference to this last idea, it is important to remember that the aim of the AI is not to beat the player always, since the fun and motivation would be lost, but rather to create an experience as realistic as possible.

There are even studies that have analyzed the feasibility of Deep reinforcement learning for serious games [14]

In addition to Deep reinforcement learning, genetic algorithms have brought improvements in this area. In [15] AI characters for fighting games can be generated with the help of genetic algorithms and through a low-cost process. Moreover, it has also been used in a soccer simulator (Robocup Soccer) with the aim of improving decision making in the simulation of soccer teams [16]. The result of the implementation of this enhancement was that two of the three teams that made up this system were top teams in the RoboCup competition. In [17] sets out to apply genetic algorithms in real-time strategy games to learn new and effective strategies for this type of game. The problem is that these types of actions are usually abstract for the player and for this reason in this work they focus on learning strategies that can be easily interpreted by people. Furthermore, this type of algorithms have also been used in games such as Backgammon [18] or Chess [19].

In the previous paragraphs, a series of applications have been shown that are far from the AI techniques used in the first video games, which were defined by rule-based systems, that constitute the most basic algorithms in AI. More complex and innovative structures such as Deep learning or genetic algorithms are currently integrated. However, there is an AI technique called fuzzy logic that, despite not being as popular as neural networks, is very useful for this type of development and will be described below.

Fuzzy Logic is advisable for solving many problems where the uncertainty is a main actor, for instance the uncertain multi-criteria decision making problem [20]. It is broadly used in controllers where it is hard to obtain a mathematical model, or systems that need to work with some vagueness or ambiguousness. Some applications created with fuzzy logic would be medical applications [21], daily life applications as the washing machine [22], natural interaction with face recognition [23] and posture recognition [24] and lastly smart cities. Perhaps the last one could be disconcerting, notwithstanding the growth of cities has generated various problems in them. The administration of aspects such as waste collection, environmental pollution, traffic, energy distribution or water, becomes an increasingly complex task. Fuzzy logic has contributed to energy efficiency in smart cities [25].

Recently the Unity engine has finally embraced artificial intelligence, adding Machine Learning (ML) to its pathfinding tool. The most outstanding open-source plugin that this game engine has it is called ML-Agents. This plugin enables games and simulators to become a training environment to train artificial intelligence agents through reinforcement learning [32]. Anyhow, if a developer wants to implement another technique the first stop is the Unity’s Assets Store, filled with thousand of plugins. But among all the variety of tools available, those intended for implementing AI are scarce, and only one of them is based on fuzzy logic. This plugin is just a Fuzzy Logic layer for another tool aimed to build fighting games. The best solution is using an external library called AForge.net (AForge.NET). Written in C#, is an AI library that includes an API for working with Neural Networks, Artificial Vision, and Machine Learning, among others. Given the broad scope of the library, the Fuzzy Logic implementation is shallow but easy to use. It has no Unity integration, so it lacks of GUI and makes it harder to use by staff like designers. The project is open source with a LGPLv3 license, so it can be easily extended, but our tool already has most of the elements it lacks like more membership functions, operators, or defuzzification methods. Ithaca was built from scratch thinking in Unity, so it implements components that can be attached to game objects. It also has a GUI for defining a system and debugging it without writing a single line of code. All these makes our solution more complete, more powerful and flexible, and thanks to its integration with Unity, easier to use.

Ithaca is a tool for integrating a Fuzzy Logic Inference System (FIS) on any project developed with the Unity engine. It is written in C# but it is not compiled, so all code is available to the developer for any needed modification. This makes the tool platform-independent, allowing to use it in any device among the ones available in Unity. Its core consist in a Fuzzy Rule Based System (FRBS) that evaluates a set of rules which are formed by fuzzy sets and fuzzy logic.

The fuzzy inference system implemented in Ithaca uses the Mamdani model, where the consequent of the IF-THEN rules is a fuzzy statement like this:

This way of writing rules is natural and intuitive, making it more suitable for developing systems where we are trying to simulate human decision making. This model is less efficient than the Sugeno model, where the consequent of the rules are algebraic expressions [33] so the defuzzifying step is faster to compute. For defuzzifying Mamdani FIS we implemented the next methods:

• •

  Centroid or Centre of Gravity (COG):

  $$COG=\frac{\int_{min}^{max}x\mu(x)dx}{\int_{min}^{max}\mu(x)dx}$$

• •

  Centroid for Singleton (COGS):

  $$COGS=\frac{\sum_{i}x_{i}\mu_{i}}{\sum_{i}\mu_{i}}$$

• •

  Bisector or Centre of Area (COA):

  $$COA=u^{\prime},\int_{min}^{u^{\prime}}\mu(u)du=\int_{u^{\prime}}^{max^{\prime}}\mu(u)du$$

• •

  Mean of Maximum (MOM):

  $$MOM=\frac{\int_{A_{max}}xdx}{\int_{A_{max}}dx}$$

• •

  Right Most (RM):

  $$RM=\{x|x>x^{\prime},\forall x^{\prime}\in A_{max}\}$$

• •

  Left Most (LM):

  $$LM=\{x|x<x^{\prime},\forall x^{\prime}\in A_{max}\}$$

For the fuzzifying interface we wrote twelve membership functions, being some of them specific cases from more general functions, but broadly used. Regarding the logical connectives for the rules’ elements, conjunction can be defined by a set of different t-norm methods. The same happens to the union, which may be defined using one of various t-conorms. All the methods implemented are:

• •

  Membership functions:

  • –

    Singleton.

  • –

    Piecewise.

  • –

    Triangle.

  • –

    Trapezoid.

  • –

    Grade.

  • –

    Reverse grade.

  • –

    Gaussian.

  • –

    Double Gaussian.

  • –

    Bell.

  • –

    Cosine.

  • –

    Sigmoidal.

  • –

    Difference of sigmoidals.

• •

  T-Norm (AND operation):

  • –

    Min (Gödel-Dummett).

  • –

    Product

  • –

    Bounded Difference (Łukasiewicz).

• •

  T-CoNorm (OR operation):

  • –

    Max.

  • –

    ASUM.

  • –

    BSUM.

  • –

    NSUM.

The system architecture is divided in three subsystem; the core, the graphics subsystem, and the parser. The core subsystem has three main components (Figure 1):

1. 1.

   The fuzzifier interface: this is where the crisp input values are turned into fuzzy values depending on the membership functions.

2. 2.

   The inference system: all the rules are evaluated here. The antecedents determine the value of the consequences and the result is a fuzzy value.

3. 3.

   The defuzzifier interface: the outputs are turned into crisp values in order to be used in the game.

The graphics subsystem is formed by the classes for the GUI and an additional set of classes, in a separated namespace, for drawing the graphs for the membership functions (Figure 3). Unity has no built-in system for drawing graphs, so we had to build our own plugin. We made it decoupled from the rest of the GUI so it could be used in other cases. At last, the parser subsystem translates the FCL files to the Ithaca inner format.

The inference engine structure is based in the FCL’s definition, where a system is represented by a Function Block (FB), which in turn is defined by a set of Linguistic Variables (LV) as inputs and outputs, and a set of rules or Rule Block (RB). Each LV represents a domain of knowledge, and if declared as input has as many fuzzy sets as needed. Each fuzzy set has a membership function that defines the degree of correspondence of an input value to this set. On the other side, if a LV is declared as output, it has an additional defuzzifier method to translate the fuzzy values to crisp values. The rules set is changeable in runtime, making it possible to adapt the knowledge base depending of the needs.

Once a system is defined using the API, GUI, or a FCL file, the inference engine can be called during gameplay asking for an output depending on the current value, or with a new value.

The GUI has a main window with three tabs (see Figure 2):

• •

  One for creating/loading a system

• •

  Another one for defining input and output variables

• •

  The last one to write sets of rules

The first tab lets the user create a new system or import one already defined. The systems can be exported to JSON format, and be loaded back from JSON and also from an FCL file. This lets the users save and exchange systems in a format trackable by version control software. Once the system is created, an asset file is created in the Unity project. This is a binary file with a serialization of the full system. If the asset file is selected, it can be edited from this window. The second tab is for declaring the input and output linguistic variables. Once the LV is created, it can be edited in order to add the fuzzy sets and its membership functions (Figure 3). The user can declare the limits of the LV and its default value.

Finally, in the third tab, the user can define sets of rules written in natural language (Figure 4). For each set of rules the user can decide the methods for the operations. This operations are:

• •

  The methods for the logic operations AND/OR, also called aggregation operation. In order to satisfy De Morgan’s law the methods must go in the following pairs:

  • –

    Min-Max

  • –

    Prod-ASUM

  • –

    BDIF-BSUM

• •

  The methods for the activation operation. This operation translates the result of the antecedent to the consequent.

  • –

    Min

  • –

    Prod

• •

  The method for the accumulation operation. This operation takes the results from the consequent of all fired rules and combines its values to obtain one output.

  • –

    Max

  • –

    BSUM

  • –

    NSUM

If the used defines more than one set of rules, a default one must be choosen. As we said, the RB can be changed during runtime.

There is also an additional window, the debugger. It lets the developer debug both the graphs values and the rules that fired and its values. (Figure 5).

The main features of the Ithaca tool are:

• •

  A powerful GUI that allows to define a full system using graphs.

• •

  The inference system used is Mamdani, which uses fuzzy sets as outputs for the rules. This way the output is easier to use by the developer in most cases.

• •

  Covers the most used membership functions, defuzzifier methods, and operation expressions. The user can define new functions, methods, or expressions.

• •

  It is not compiled, thus the user can modify the code as needed within Unity.

• •

  A graphical debugging system that allow to check in real time the input and output values, as well as the values of every rule and if it was fired.

• •

  It can be used to build games in any platform available in Unity.

The goal of this test was to build a complex system using our tool, and to check the compliance with the FCL standard. So we decided to use the crane system defined in the FCL standard [6], that controls container crane that loads and unloads containers from ships. The controller must moves the containers taking care of the speed and angle(Figure 6). The rules of the system were:

1. 1.

   IF distance IS far AND angle IS zero THEN power IS pos_medium.

2. 2.

   IF distance IS far AND angle IS neg_small THEN power IS pos_high.

3. 3.

   IF distance IS far AND angle IS neg_big THEN power IS pos_medium.

4. 4.

   IF distance IS medium AND angle IS neg_small THEN power IS neg_medium.

5. 5.

   IF distance IS close AND angle IS pos_small THEN power IS pos_medium.

6. 6.

   IF distance IS zero AND angle IS zero THEN power IS zero.

The test demonstrated both the compliance with the FCL standard and the usefulness of the tool for building complex system using natural knowledge provided by specialists like a crane operator.

The objective in this test was to develop an adversary AI that looks natural and realistic, and to develop it entirely with the GUI. Many times it is important to keep the illusion that we are playing against a human to engage with the player, even if it makes our AI less optimal. The vagueness of the Fuzzy Logic makes it ideal for developing systems that act as imprecise as a human would. In this case we built two race cars, both with the same sensors and almost the same set of rules. But one, called ”Classic car”, used classic logic, while the ”Fuzzy car” used our inference system. The knowledge base used was:

1. 1.

   IF Front IS Normal THEN Steering IS Straight, Speed IS Somewhat Fast.

2. 2.

   IF Front IS Far THEN Steering IS Straight, Speed IS Very Fast.

3. 3.

   IF Left IS Close THEN Steering IS Right.

4. 4.

   IF Right IS Close THEN Steering IS Left.

5. 5.

   IF VeryLeft IS Close THEN Steering IS VeryRight.

6. 6.

   IF VeryRight IS Close THEN Steering IS VeryLeft.

The results were that the fuzzy car was faster and its trajectory was much more natural (Figure 7). As for the use of the GUI, the system revealed itself as faster than using the API.

• •

  To implement Combs method for reducing the number of rules needed by combining them.

• •

  To add the option to create Fuzzy Finite State Machines (FuFSM). The FSM is a very popular technique among game developers and the use of FL can provide a degree of uncertainty very valuable in some cases.

• •

  To generate the knowledge base implementing Adaptive Network-based Fuzzy Inference System (ANFIS)[34]. This would allow creating more powerful systems thanks to the use of NN.

• •

  To implement Takagi-Sugeno method for inference.

• •

  To implement the new Fuzzy Markup Language (FML), based on XML [35].