KR20230146220A - Computer graphic game programming system for artificial intelligence education - Google Patents

Abstract

An input module that receives coding blocks written by the user; and converting the coding block into a preset programming language to generate an executable code, constructing a game simulation environment based on environment information and object information included in the executable code, and based on result data generated during the game simulation process. Provides a computer graphics game programming system for artificial intelligence education, including a server system that generates learning data and updates the simulation environment by learning the learning data based on a preset algorithm.

Description

Computer graphics game programming system for artificial intelligence education purposes {COMPUTER GRAPHIC GAME PROGRAMMING SYSTEM FOR ARTIFICIAL INTELLIGENCE EDUCATION}

The present invention relates to a programming system, and specifically to a computer graphics game programming system that allows users to experience education on artificial intelligence (AI).

AI is an area where computers perform tasks that can be done with human intelligence, such as sentence understanding, image recognition, voice recognition, and learning. AI will be used in conjunction with augmented reality, the Internet of Things, edge computing, and digital twins to provide highly integrated smart spaces, and ultimately, a highly advanced artificial intelligence-led development environment that automates both functional and non-functional aspects of applications. This will usher in a new era of citizen application developers where even non-experts can automatically create new solutions using artificial intelligence-related tools. Tools that allow non-experts to create applications without coding are not new, but we believe that artificial intelligence-driven systems will provide a new level of flexibility.

An embodiment of the present invention provides a system that provides users with an educational experience in AI programming or coding by incorporating AI into a computer graphics game, for example, a soccer game, and providing a programming or coding environment to the user for the integration. .

According to an embodiment of the present invention, an input module that receives a coding block written by a user; and converting the coding block into a preset programming language to generate an executable code, constructing a game simulation environment based on environment information and object information included in the executable code, and based on result data generated during the game simulation process. Provides a computer graphics game programming system for artificial intelligence education, including a server system that generates learning data and updates the simulation environment by learning the learning data based on a preset algorithm.

According to an embodiment of the present invention, an educational experience in AI programming or coding can be provided to the user by incorporating AI into a computer graphics game, for example, a soccer game, and providing a programming or coding environment to the user for the integration.

Figure 1 is a diagram showing the correlation between artificial intelligence, machine learning, and deep learning
Figure 2 shows the Atari game framework including states, actions, and rewards.
Figure 3 is a diagram showing a deep neural network that determines actions depending on the state of the Atari game displayed on the screen.
Figure 4 is a diagram showing the structure of an Atari game replaced by a deep neural network that selects the behavior of the Atari game based on the state of the game screen.
Figure 5 is a diagram showing the AI soccer structure replaced by a deep neural network that selects robot actions according to the game state.
Figure 6 is a diagram illustrating an AI soccer robot play environment
Figure 7 is a diagram showing the download page of the Webots simulator provided by Cyberbotics Ltd.
Figure 8 is a diagram showing the Webots simulator Preferences selection window
Figure 9 is a diagram illustrating an interface for adding PYTHONPATH to system environment variables.
Figure 10 is a diagram showing the AI soccer simulator download page
Figure 11 is a diagram illustrating commands in case of installing a deep learning library without using GPU
Figure 12 is a diagram illustrating the structure of an AI soccer simulator
Figure 13 is a diagram illustrating the Webots simulator execution window
Figure 14 is a diagram illustrating an AI soccer stadium for youth robots and an AI soccer stadium for adult robots
Figure 15 is a diagram illustrating an AI soccer robot for youth and an AI soccer robot for adults
Figure 16 is a simplified diagram of the physical shape of the youth AI soccer robot and the adult AI soccer robot performed internally by the Webots simulator.
Figure 17 is a diagram illustrating an AI soccer robot
Figure 18 is a diagram illustrating three actions of the robot
Figure 19 is a diagram illustrating a dribble area
Figure 20 is a diagram illustrating a soccer ball
Figure 21 is a diagram illustrating the communication structure between the AI soccer simulator and gamer code
Figure 22 is a diagram illustrating information transmitted and received between the AI soccer simulator and gamer code
Figure 23 is a diagram illustrating image information provided to gamers
Figure 24 is a diagram illustrating possible actions of the robot
Figure 25 is a diagram illustrating a web-based AI soccer code generator
Figure 26 is a diagram illustrating a rule-based AI soccer code generator
Figure 27 is a diagram illustrating block categories of the rule-based AI soccer code generator
Figure 28 is a diagram illustrating 'Environment indices' among the block categories of the rule-based AI soccer code generator.
Figure 29 is a diagram illustrating 'Environment Constants' among the block categories of the rule-based AI soccer code generator.
Figure 30 is a diagram illustrating 'Environment variables' among the block categories of the rule-based AI soccer code generator.
Figure 31 is a diagram illustrating 'Environment fucntions' among the block categories of the rule-based AI soccer code generator.
Figure 32 is a diagram illustrating code by a rule-based AI soccer code generator
Figure 33 is a rule-based example code diagram defined by high-level actions.
Figure 34 is a diagram illustrating the generated code
Figure 35 is a diagram illustrating the coordinate system and angle system for competition
Figure 36 is a diagram illustrating the names of field areas of the stadium
Figure 37 is a diagram illustrating a kickoff formation (ball possession team: A)
Figure 38 is a diagram illustrating corner kick formation 1 (ball possession team: A) during defense.
Figure 39 is a diagram illustrating corner kick formation 2 (ball possession team: A) during defense.
Figure 40 is a diagram illustrating corner kick formation 1 (ball possession team: A) during attack
Figure 41 is a diagram illustrating corner kick formation 2 (ball possession team: A) during attack
Figure 42 is a diagram illustrating a penalty kick formation (ball possession team: A)
Figure 43 is a diagram illustrating a goal kick formation (ball possession team: A)

BRIEF DESCRIPTION OF THE DRAWINGS Various embodiments of the present invention are described below with reference to the accompanying drawings. However, this does not limit the present invention to specific embodiments, and should be understood to include various modifications, equivalents, and/or alternatives to the embodiments of the present invention. In connection with the description of the drawings, similar reference numbers may be used for similar components.

In this document, expressions such as “have,” “may have,” “includes,” or “may include” refer to the presence of the corresponding feature (e.g., a numerical value, function, operation, or component such as a part). , and does not rule out the existence of additional features.

In this document, expressions such as “A or B,” “at least one of A or/and B,” or “one or more of A or/and B” may include all possible combinations of the items listed together. . For example, “A or B”, “at least one of A and B”, or “at least one of A or B” (1) includes at least one A, (2) includes at least one B, or (3) it may refer to all cases including both at least one A and at least one B.

Expressions such as “first,” “second,” “first,” or “second” used in various embodiments may modify various elements regardless of order and/or importance, and refer to the elements. It is not limited. For example, a first user device and a second user device may represent different user devices regardless of order or importance. For example, the first component may be renamed to the second component without departing from the scope of the present invention, and similarly, the second component may also be renamed to the first component.

A component (e.g., a first component) is “(operatively or communicatively) coupled with/to” another component (e.g., a second component). When referred to as “connected to,” it should be understood that any component may be directly connected to the other component or may be connected through another component (e.g., a third component). On the other hand, when a component (e.g., a first component) is said to be “directly connected” or “directly connected” to another component (e.g., a second component), It may be understood that no other component (e.g., a third component) exists between other components.

The expression “configured to” used in this document means, for example, “suitable for,” “having the capacity to,” depending on the situation. ”, “designed to”, “adapted to”, “made to”, or “capable of”. The term “configured (or set) to” may not necessarily mean “specifically designed to” in terms of hardware. Instead, in some situations, the expression “device configured to” may mean that the device is “capable of” working with other devices or components. For example, the phrase “processor configured (or set) to perform A, B, and C” refers to a processor dedicated to performing those operations (e.g., an embedded processor), or executing one or more software programs stored on a memory device. By doing so, it may mean a general-purpose processor (for example, a CPU or application processor) capable of performing the corresponding operations.

Terms used in this document are merely used to describe specific embodiments and may not be intended to limit the scope of other embodiments. Singular expressions may include plural expressions, unless the context clearly indicates otherwise. All terms used herein, including technical or scientific terms, may have the same meaning as commonly understood by a person of ordinary skill in the technical field of the present invention. Terms defined in commonly used dictionaries can be interpreted as having the same or similar meaning as the meaning they have in the context of related technology, and unless clearly defined in this document, they are not interpreted in an ideal or excessively formal sense. . In some cases, even terms defined in this document cannot be interpreted to exclude embodiments of the present invention.

AI refers to artificial human intelligence that imitates and executes functions related to human abilities, such as learning and problem solving. AI can be divided into expert systems that consist of rules as knowledge and machine learning that learns and acquires algorithms on its own. This disclosure provides rule-based AI soccer example code and learning-based example code.

Machine learning is an important field in AI. It can be said that AI includes machine learning, as shown in Figure 1, and machine learning includes deep learning. Machine learning is a technique that analyzes given data and learns (trains) itself to find rules and characteristics of the data. This is a field that allows computers to learn by providing data to them, just like humans learn, to gain new knowledge. The development of a machine learning algorithm consists of three stages: learning (learning), testing (validation), and inference. In the learning stage, a mapping function for the desired task is obtained based on the given input data. In the testing phase, we test whether the previously learned mapping function can be applied to data that has not yet been examined. In the inference stage, the learned mapping function is applied to arbitrary data for the desired task. Currently, various machine learning algorithms are being developed. Representative machine learning techniques include supervised learning, unsupervised learning, and reinforcement learning. Supervised learning gives a predetermined output for a given input at the learning stage. A neural network trained through supervised learning provides output values for input, similar to the role of a mapping function. However, in the case of unsupervised learning, only input is given. Unsupervised learning is mainly used for clustering, which classifies various input data into groups. Reinforcement learning deals with what actions an agent should take in the environment to maximize the cumulative reward. For example, an agent playing chess receives a reward after taking actions that move the pieces on the chessboard. In this case, the chessboard and pieces are considered an environment with which the agent can interact. State can be defined as the current position of the pieces on the chessboard. Cumulative rewards can be designed based on criteria such as eliminating the opponent's pieces or winning the game. In this case, if the opponent's piece is eliminated or wins, you will receive a positive number of rewards. To maximize the accumulated reward (the reward received in the future), the agent's goal will be to make moves that maximize the chance of winning while eliminating the opponent's pieces. The performance of a reinforcement learning algorithm basically depends on how the states, actions, and rewards are designed for a specific environment.

Deep learning is a type of machine learning that extracts features of data using an artificial neural network with multiple layers, allowing it to cope with different situations on its own. Artificial neural network is a general term for systems implemented by focusing on the neural network of the human or animal brain. Application fields using deep learning include computer vision, speech processing, and natural language processing. Recently, deep learning has been attracting attention as it is used in Google's Youtube, Facebook's News feed, and general image analysis. The reasons why deep learning achieved groundbreaking results include an environment that enabled big data collection, improved computer calculation capabilities using GPUs, and the development of new algorithms. A large amount of data is required to obtain an effective deep learning algorithm. Even if there is big data, it is difficult to process it when the computer's calculation speed is slow. Recently, parallel processing of computer operations has become possible using GPUs, making it possible to process a lot of data in a short period of time.

The process of converting language expressed in natural language, such as human language, into a form that computers can understand is called Natural Language Processing (NLP). Sentence classification, video title creation, machine translation, and chatbots are representative examples of natural language processing. Artificial neural networks mainly used in NLP applications are called ‘Recurrent Neural Networks (RNN).’ Recurrent neural networks are often used in natural language processing in everyday applications such as Google Translate. Another application area that uses RNNs is speech processing, especially speech synthesis and speech recognition. Applications widely used in this field include Apple Siri and Google Alexa. Speech recognition converts voice into text, and speech synthesis converts text into speech. Voice processing is attracting attention as a next-generation human-computer interface because it allows both hands to move freely while giving commands to the computer. AI speakers and voice assistants for homes and self-driving cars are applications that use speech processing.

From the beginning of AI research, games have been widely used to measure AI performance. Deep Blue, an AI chess program developed in 1996, beat world champion Kasparov and displayed play that was above human level. After achieving good results in chess and Backgammon games, researchers began thinking about applying AI to the game of Go. At the beginning of Baduk, there are 361 (19x19) landing points, and as the game continues, each side has approximately [361-2(n-1)]!(n=1,...,181) cases. Since the game can be played until it is filled, it was considered impossible to beat a professional player with simple AI. In 2016, AlphaGo, developed by DeepMind, proved the power of AI by beating the best Go player, Lee Sedol, 4:1. AlphaGo uses a reinforcement learning algorithm that learns to improve quality by competing against itself with different game strategies. AlphaGo used a reinforcement learning (RL) algorithm that continuously tries different strategies from its own. The advantage of the reinforcement learning framework is its flexibility, which allows it to be effectively applied to environments such as board games and video games. Recently, ‘Deep Q Network (DQN)’, a method that combines reinforcement learning and deep learning, has been successfully applied to Atari games and is attracting a lot of attention. Reinforcement learning aims to design a policy that represents the mapping between states and actions by using neural networks and combining them with deep learning. The output of DQN is the Q-value of each action that can be performed in a specific state. The Q-value represents the future cumulative reward that the agent will receive if it takes the corresponding action. The agent wants to take an action that will receive the maximum cumulative reward in the future, so it tries to take an action that has the highest Q-value. Reinforcement learning consists of functions of state, action, and reward. Taking an Atari game as an example, the state will be the game screen, the reward function can be replaced with the current score, and the action will be an action possible in the video game controller as shown in Figure 2. . The way a person plays a game is configured using a deep neural network, as shown in Figure 3. In Figure 3, the “Convolution” layer extracts the features of the image, and the “Fully connected:” layer determines actions based on this. Therefore, as shown in Figure 4, the artificial neural network replaces the game played by humans. To develop AI Soccer algorithms, a reinforcement learning framework combined with deep learning can be used. The difference between Atari, Go, and chess games and AI soccer is that soccer involves multiple robots interacting dynamically. AI soccer, similar to the Atari game, can be interpreted as shown in Figure 5.

In Figure 5, the gamer must determine the movement of each robot based on the coordinates and directions of the robots and the ball. Parts related to behavior, such as where and how the robot should move, will be explained in detail below. As in the example of Atari games, neural networks can be used to map state information to actions at each time step.

AI Soccer is a 5:5 robot soccer game in which each team controls five robots to develop an algorithm to beat the opposing team. You can use the provided program to develop gamer programs in the Python programming language. The gamer program can control a total of five robots by adjusting the wheel speed of each robot and kick and jump movements based on robot and ball coordinates. The movement of the AI soccer robot is determined by the speed of the wheels, which are invisible but can be controlled by code. Details are described below. Gamers with basic knowledge of Python can create their own robot soccer strategies.

To run AI soccer, the following computer hardware specifications are required, for example:

- Dual-core CPU with a minimum clock speed of 2GHz or more and RAM of 2GB or more

- A graphics adapter capable of supporting NVIDIA or AMD OpenGL (version 3.3 or higher) and a graphics card with at least 512MB of graphics RAM.

If you want to use deep learning using GPU, it is recommended to use an NVIDIA graphics card and install the provided CUDA and cuDNN libraries. Even if you do not use a GPU, you can install the deep learning library. Available computer operating systems (OS) are, for example:

- Windows 8.1 and Windows 10

- Ubuntu Linux OS (16.04 or later)

To install AI Soccer simulator, you must go through the following steps.

1) Install Webots simulator.

2) Install Python interpreter.

3) Download the AI Soccer simulator file.

4) Install deep learning library

If the Python interpreter is already installed, you can skip step 2). If gamers plan to use the deep learning example code, an additional step is required to install the deep learning library. To run the deep learning example code, you must follow the installation of the deep learning library in “Installing the deep learning library” in 2-3-4 (WIDOWS) or 2-4-4 (LINUX). In the deep learning example code, PyTorch is used as the main deep learning library. This disclosure presents Tensorflow as another option for a deep learning library. To install the deep learning library without GPU support, follow the “Installing the deep learning library without GPU” procedure in 2-3-4 (WINDOWS) or 2-4-4 (LINUX). If you have an NVIDIA graphics card and want to use the ability to train deep learning algorithms, follow the “Installing deep learning libraries to use GPU” procedure in 2-3-4 (WINDOWS) or 2-4-4 (LINUX). .

Unlike other games, AI soccer uses Webots (referring to robots that operate on the web) simulators as the basis of the game environment. Therefore, you must install the Webots simulator to play AI soccer. Figure 7 shows the download page of the Webots simulator provided by Cyberbotics Ltd. as an example of the Webots simulator.

After completing the installation of the Webots simulator, follow the process of ‘Tools’ → ‘Preferences’ → ‘General’ → ‘Startup mode’ in the Webots simulator and set the Start mode to ‘Pause’. Set the Python command to ‘python’. Python commands vary depending on Python interpreter installation. Figure 8 shows the Webots simulator Preferences selection window.

To run the AI soccer simulator on the Webots simulator, add Webots' PYTHONPATH to the environment variables (System Properties → Environment Variables → System Variables → New). After installing the Python interpreter, set PYTHONPATH to match the version of Python installed on your computer. For example:

“PYTHONPATH = ${WEBOTS_HOME}/lib/controller/python3X”

“python3x” is related to the installed version of Python. This process is as shown in Figure 9.

To run AI soccer on Windows, Python (interpreter) is required. The recommended version is Python 3.7. It is possible to install Python manually or using Anaconda (which includes essential libraries such as numpy for developing machine and deep learning programs). If you are not familiar with installing Python manually, we recommend installing Python using Anaconda.

AI Soccer Simulator is a package containing AI soccer game implementation and example code. The AI soccer simulator is installed in the Webots simulator in the form of a world (environment). Go to https://github.com/aisoccer/aisoccer-3d/releases and download the AI soccer simulator. Figure 10 shows the AI soccer simulator download page. To use the AI soccer simulator on Windows, download the ‘aioccer-3d.zip’ file included in “v0.1 Release Windows”. The AI soccer simulator is already capable of running rule-based example code. You can test your installation using rule-based example code. Meanwhile, to run deep learning examples, install the deep learning library. If you have an NVIDIA graphics card that is compatible with the deep learning library, you have two options:

- Use deep learning libraries without using GPU

- Deep learning library using GPU

If you have an NVIDIA graphics card, you can use your graphics card to use deep learning libraries to improve your computer's performance. Install NVIDIA drivers and software, CUDA and cuDNN. If you do not want to use the GPU support library, you can run deep learning using the deep learning library using only the CPU. We will install the necessary programs in the following order.

- NVIDIA DRIVER

- CUDA

-cuDNN

- Deep learning libraries: Tensorflow, PyTorch

In the case of installing a deep learning library that does not use GPU, install Tensorflow and PyTorch by executing the command as shown in Figure 11 through the ‘pip’ package manager in the terminal. In this case, it is okay to just install PyTorch.

In the case of installing the deep learning library to use the GPU, the NVIDIA driver must be installed when running AI Soccer to use the game simulator at smooth speed. If you do not have an NVIDIA GPU on your computer, you cannot install the driver. Even if you do not have an NVIDIA driver on your computer, you can use the simulator, but soccer will run at low speed.

Webots Simulator works if you have a GPU. However, since installing CUDA and cuDNN is relatively difficult, beginners can just install PyTorch. It is possible to write learning-based code with PyTorch alone. To use deep learning libraries such as Tensorflow and PyTorch, install CUDA and cuDNN along with the NVIDIA driver. To use learning-based code, install the NVIDIA driver, CUDA, and cuDNN, then use the command prompt (cmd) window or Anaconda prompt to install the Tensorflow or PyTorch you want to use with the command.

Ubuntu 18.04 is one of the operating systems (OS) that creates a computer environment like Windows 10, and is an operating system optimized for robot simulator and programming development. Ubuntu 18.04 is a stable long-term support (LTS) version. Unlike Windows, the operating system itself is written in the Python language, so there is no need to install Python separately, and most installations can be done through commands in a terminal window. In Ubuntu, you can run the program through the terminal command: webots. After installing the Webots simulator, go to ‘Tools’ → ‘Preferences’ → ‘General’ → ‘Startup mode’ in the Webots simulator menu and set it to pause mode. Also, set ‘Python command’ to ‘python’. To use the AI soccer simulator in the Webots simulator, add Webots' PYTHONPATH to the environment variables. After installing Python, set PYTHONPATH according to the Python version (‘python3x’). In Ubuntu, PYTHONPATH must be loaded every time before running the Webots simulator. Even without opening a separate page using the terminal, you can perform the loading task using the command below. If you do not want to add PYTHONPATH every time you run Webots, add the PYTHONPATH variable to the ‘~/.bash_profile’ file.

In general, Ubuntu OS has a Python interpreter installed by default. Install the necessary libraries through the PIP package manager.

- numpy

- opencv-python

Unlike the Anaconda Python environment on Windows, in Ubuntu, you must install pip and Python essential libraries using a command in the terminal. To use learning-based code, install NVIDIA drivers, CUDA, and cuDNN, then install Tensorflow and PyTorch using commands in the terminal.

The downloaded and unzipped AI soccer simulator has the same structure as Figure 12. The ‘controllers’ folder contains the supervsor function and has nothing to do with writing gamer code. The ‘pluggins’ folder contains codes related to detection of collisions between robots that occur during game progress. The ‘protos’ folder contains detailed information about the game’s robots and stadiums. The ‘reports’ folder is related to writing game articles. The ‘worlds’ and ‘examples’ folders are important to gamers. The ‘worlds’ folder contains all the environments for youth and adult robot competitions, which must be opened in the Webots simulator. The ‘examples’ folder contains example code to use as a reference to develop your own strategy. There are two world files in the ‘worlds’ folder: ‘aisoccer_1.wbt’ and ‘aisoccer_2.wbt’. The world file ‘aisoccer_1.wbt’ is an environment where games are played using youth robots, and the world file ‘aisoccer_2.wbt’ is an environment where games are played using adult robots. To check the installation, you can open the Webot simulator and press ‘Ctrl + O’ to open the world file. When you select the World file you want to run in the ‘Worlds’ folder, the simulator runs as shown in Figure 13. If you open the ‘config.json’ file in the root folder of the AI soccer simulator and enter your e-mail address and license, a rules-based match between two teams will be played.

Using the Webots simulator editor, open the ‘config.json’ file to configure game options, insert license (e-mail address and signature key), and set gamer strategy codes. Using only the basic configuration, Team A will be the team that moves the robot randomly, and Team B will be the team that operates the robot according to a simple rule base. Code written by gamers can be used by specifying a path. The parts related to AI Soccer gamers are rule, team_a, team_b, and tool. The game_time in the rule is the game time for the first and second halves and can be changed as desired by the gamer. For example, the ‘config.json’ file can be structured as shown in Table 1 below.

item meaning rule Consists of Game_time (game time) and deadlock (deadlock = if the ball does not move due to deadlock due to contact between robots for 4 seconds, the ball is relocated) Game_time Game time (default: 300 seconds) deadlock If set to False, rules for deadlocks will be ignored (default: True). Team_a
Team_b Decide which soccer team will play. Consists of name, executable, datapath, keyboard name team name executable AI Soccer Executable File Path
(Both teams must be correctly assigned to run AI soccer) data path Path where AI can output some files keyboard If set to True, the robot can be operated using the keyboard. commentator
reporter Set information for AI soccer commentators and reporters (used in other AI WorldCup sports) tool If set to True, the game will repeat with the same game options after the game ends. When True, ‘GAME_END’ in ‘reset_reason’ is replaced with ‘EPISODE_END’ (default: False). multi_view If set to True, the 3D camera will follow the ball during the game and change the camera used in some situations.
It is recommended to leave it as False during the code development and testing stages. record If set to True, the game will be recorded and saved in “record_path” when the game is over. Cannot be used with “repeat”. If “repeat” is True, “record” becomes False internally (default: False).
It will take a few minutes for the recorded video to be saved after the game ends.
You must wait until the message ‘Video creation finished.’ appears in the Webots Console (Ctrl + L). record_path Path to save the recorded video (default: “”). This is a path, not a video file name.
The file name is automatically '[{timestamp}]{team_a_name}_{team_b_name}. It is set to 'mp4'. If used as default, the video will be saved in the root path. You must specify an appropriate path to save the video. replay If set to True, when a goal is scored, video is played from 3 seconds before the goal to 3 seconds after the goal is scored. If the “multi_view” option is True, replay videos from different angles are played. license Check the gamer's information.
Consists of email and signature email Enter the gamer’s email address signature Enter the signature key received from the administrator (if you enter a different value, the game will not proceed.)

After editing the config.json file, run AI soccer by pressing the 'Ctrl + 2' key (Play Button). The AI soccer stadium for youth robots and the AI soccer stadium for adult robots are shown in Figure 14. It's like a bar. The AI soccer stadium for adult robots is 1.3 times larger than the AI soccer stadium for youth robots.

AI soccer robots can be divided into three types: goalkeeper (GK), defender (D1, D2), and attacker (F1, F2). Figure 15 shows an AI soccer robot for youth and an AI soccer robot for adults. The only difference between AI soccer robots and AI soccer robots for adults is their visual shape and size. The visual appearance shown in Figure 15 matches how the robot appears on the Webots simulator screen. Visual forms include arms, legs, and head. The physical appearance performed internally by the Webots simulator is shown in Figure 16, which is a simplified form of the visual appearance. The physical height and foot size of the robot shown in Figure 16 are the same as the height and foot size of the visual shape shown in Figure 15. Other parts are simplified internally in the simulator for convenience in running the game. The simplification concerns how the robot comes into contact with the ball, the wall, and other robots. The robot's body specifications consist of a head, torso, and a box-shaped lower body that replaces the legs. Arms are included in the physical shape only for goalkeepers. You can check the physical specifications of the robot by clicking on it in the Webots simulator. Inside the robot, there are two wheels and additionally two sliders, as shown in Figure 17. The left and right wheels move separately (differentially) and are used for the movement of the robot. More details on the use of differential wheels are described below. Two sliders are located at the front and bottom of the robot. In Figure 17, the red part under the foot corresponds to the bottom slider. The red part on the front of the foot corresponds to the front slider. The front slider is used for kick (cross, shoot, quickpass). When kicking the ball cross or high, angle adjustment can be accomplished by adjusting the height of the front (front) slider. The bottom (bottom) slider is used for jumping when heading. For goalkeepers, the slider is designed differently to create save opportunities. The slider is located below the goalkeeper and is used to slide in three directions to attempt saves forward, left, and right. A soccer robot can achieve various behavioral characteristics by varying the speed of its wheels and sliders. An example of that feature is shown in Figure 18. Figure 18 shows that the robot can move, jump, and shoot into the opponent's goal. A dribbling mode was also defined to increase the robot's ball control ability. Dribbling mode can be activated when the robot is in possession of the ball. When dribbling mode is activated and the robot gains possession of the ball, the ball moves with the robot. Even if dribbling mode is activated, it does not prevent the opposing team from entering ball possession. The rules of dribble mode are as follows. First, dribbling mode can be activated when there is a ball in the dribbling area in front of the robot. The dribbling area is a fan shape with a total of 90 degrees left and right, 45 degrees centered on the front center line, and is defined as a length of 5 to 20 cm (depending on the speed of the robot) from the circumference of the head, which appears as a circle. When the robot is stationary, it is 5cm, and when it moves at maximum linear velocity, it is 20cm. Figure 19 shows the dribble area. Second, if the ball overlaps another robot's dribbling area, the dribbling mode is canceled and both robots can take possession of the ball, resulting in a fight. Third, if you use shoot or jump while dribbling, the dribbling will end. Fourth, if the robot falls, dribbling ends. For the convenience of gamers, kick (shoot) and jump actions are pre-implemented in the ‘action.py’ file of the rule-based example code. The gamer code must set the wheel, slider and dribble mode variables for each robot at each time step and transmit them to the AI soccer simulator. Details on wheel and slider specifications are described later. The specifications of the soccer robot are as shown in Table 2 below, and some specifications are different depending on the role. The reason the goalkeeper is heavier than other robots is to avoid situations where the opposing team's defenders and attackers push the goalkeeper out of the goal area. The reason the attacker is lighter than the defender is to avoid a situation where the attacker creates a scoring opportunity by pushing the defenders out of the penalty area toward the outside of the goal.

goalkeeper defender striker Weight (Kg) 2.5 2.0 1.5 Robot center of gravity (cm) ground 1.5 left side left side Wheel weight (Kg) 0.15 each left side left side Slider weight (Kg) 0.5 each left side left side Maximum speed (m/s) 1.8 2.1 2.55 Maximum rotation torque (N*m) 0.8 1.2 0.4

A soccer ball is a simple sphere with a diameter of 10 cm and weighs 18.4 g. As shown in Figure 20, the infinity mark on the soccer ball represents the infinite types of strategies that can be developed in AI soccer. AI soccer is played by repeating attack and defense. For this purpose, the areas of the stadium corresponding to offense and defense and the robot's actions appropriate for each area must be defined. In the case of attack, it is important for each robot to move to a given location at an appropriate speed and execute crosses, kicks, and passes at an appropriate speed and height in order to maintain the formation corresponding to the game strategy. In the case of defense, positioning and passing in response to the movements of the opposing team's attackers are important. In order to proceed with such a game, information about the characteristics of the robot and the stadium is needed, and game status information that is updated at every time step is needed. Ultimately, the gamer's code uses this information to effectively set the robot's position, control the speed of movement using the wheels, and cross/kick/pass using the front and bottom sliders at the appropriate time. Information about the robot and the stadium is received through the ‘info’ dictionary, which is received only once after the game starts, and the ‘frame’ dictionary, which is received every 50ms, and the game strategy is implemented around the update() function. For reference, the time step and frame change after 50ms. Figure 21 illustrates the communication structure between the AI soccer simulator and the gamer code, and Figure 22 illustrates information transmitted and received between the AI soccer simulator and the gamer code. As shown in Figure 22, the AI soccer simulator informs the location of the robot and ball related to the game, game state, score and time, etc. whenever the gamer code is called. Gamers can control robots using wheel speed and front slider according to the game state using three virtual functions that receive game-related data from the AI soccer simulator. The three virtual functions are init(), update(), and finish(). init() is called after the gamer has successfully connected to the simulator. update() is called every 50ms. When the game ends, finish() is called.

In the AI Soccer code, three virtual functions are called.

The virtual function ‘init()’ is called only once immediately after the gamer code successfully connects to the simulator. As shown in Figure 21, preliminary information about the stadium situation and the state of the robot (information to be used in the next time step) is received from the AI soccer simulator and is used to initialize the variables needed to implement the game strategy by the gamer code. You can see how variable initialization and data recording work in the example code located in the ‘examples’ folder of the AI soccer simulator.

The virtual function ‘update()’ is called whenever the simulator sends new data to the gamer code. In AI soccer, the unit time step is set to 50ms, so the simulator also sends new data every 50ms and ‘update()’ is also called every 50ms. The data sent by the AI soccer simulator to the gamer code is called a frame. Frame data containing information about each frame of the game is contained in ‘frame’, the argument of the update() function. The ‘frame’ variable includes the image corresponding to the current state of the game, coordinates, reset reason, game state, score, and time, as shown in Figure 22. The gamer code checks the received frame data containing the contents of the current soccer game state, determines the control signal to be generated (robot motion), and transmits the control signal back to the simulator. Therefore, it is a function that implements the gamer's game strategy. The control signal transmission method is described later. Example code using rules or deep learning to generate control signals is provided in the ‘examples’ folder.

The virtual function ‘finish()’ is called only once before the gamer code ends. Here, the gamer code can save all data recorded throughout the game and can be useful for the next game.

The ‘info’ dictionary contains basic information and values that do not change during the game, such as the size of the stadium and robot specifications. This dictionary can be accessed through the ‘info’ variable received from the ‘init()’ function in the gamer code (e.g. ‘info[‘Game_time’]’ represents the game time). If there is a variable you want to use, you must save it as a class variable in ‘init()’. The information in this dictionary is the same as the information in the AI soccer basic specifications. The information in the ‘info’ dictionary is as shown in Table 3. This information and how to use dictionary values can be checked through ‘general_check-variables.py’ and ‘general_image-fetch.py’ in the example code.

Member Variable Data Type explanation field list of floats (length 2) Stadium size [x, y] (unit: m) goal list of floats (length 2) Goalpost size [x, y] (unit: m) penalty_area list of floats (length 2) Penalty area size [x, y] (unit: m) goal_area list of floats (length 2) Goal zone size [x, y] (unit: m)
※ There are no rules related to this area. ball_radius float Ball size (unit: m) ball_mass float Ball weight (unit: kg) robot_size list of floats (length 5) Robot size [GK, D1, D2, F1, F2] (unit: m)
※ Based on robot lower body (0.15m) robot_height list of floats (length 5) Robot height [GK, D1, D2, F1, F2] (unit: m) axle_length list of floats (length 5) Distance between wheels [GK, D1, D2, F1, F2] (unit: m) robot_body_mass list of floats (length 5) Robot weight [GK, D1, D2, F1, F2] (Unit: kg) wheel_raidus list of floats (length 5) Wheel radius [GK, D1, D2, F1, F2] (unit: m) wheel_mass list of floats (length 5) Wheel weight [GK, D1, D2, F1, F2] (Unit: kg) max_linear_velocity list of floats (length 5) Wheel maximum linear speed [GK, D1, D2, F1, F2] (Unit: m/s) max_torque list of floats (length 5) Wheel maximum torque [GK, D1, D2, F1, F2] (Unit: N*m) resolution list of ints (length 2) Image size [horizontal, vertical] (unit: pixel) number_of_robots Int Number of robots codewords list of ints (length 5) Decimal Hamming code assigned to robot identification image
[GK, D1, D2, F1, F2] game_time Float Game time (unit: s) team_info Dictionary Includes information from both teams key String random string key Keyboard Bool Whether to use keyboard operation

The ‘frame’ dictionary contains information about each frame of the game and is related to the current game state. As the game progresses, the information received from the ‘frame’ dictionary, such as the coordinates of the robot and the ball, varies at each time step. Each time ‘update()’ is called, a new ‘frame’ variable is received with the updated data. For example, FRAME[‘coordinates’][MY_TEAM][GK][X] is the x coordinate of our team's goalkeeper. The coordinate value is obtained by sequential top-down expression from the frame to the x coordinate. MY_TEAM, GK, and X must be predefined. The information of the ‘frame’ dictionary is as shown in Table 4. Table 5 shows coordinate information.

variable data type explanation Time float Current match time (unit: seconds) Score list of ints (length 2) Current score [your team, opposing team] reset_reason int The reason the game was paused just before the current frame.
This value is one of the following values:
NONE - No pause.
GAME_START - Immediately after the game starts, the game begins with kickoff.
SCORE_MYTEAM - Your team scores, and the game progresses with kickoff.
SCORE_OPPONENT - Opponent team scores, game progresses with kickoff.
GAME_END - End of game.
DEADLOCK - Ball relocation.
GOALKICK - Play is started with a goal kick.
CORNERKICK - Play begins with a corner kick.
PENALTYKICK - Play is played with a penalty kick.
HALFTIME - Immediately after the start of the second half, the game begins with kickoff.
EPISODE_END - Immediately after the game ends (replaced with GAME_END if 'repeat' option is on). game_state int Current game status
This value is one of the following values:
STATE_DEFAULT - default
STATE_KICKOFF - kickoff
STATE_GOALKICK - Goal kick
STATE_CORNERKICK - corner kick
STATE_PENALTYKICK - penalty kick ball_ownership Bool An indicator of whether your team has the ball (True) or not (False) in situations such as kickoff, corner kick, penalty kick, and goal kick. This value has no meaning in the default state. half_passed Bool Indicator indicating whether the current game is in the first half (False) or the second half (True) subimages list of items To obtain a new frame, image fragments must be merged with the previous image frame.
Not important since the coordinates of the robot and the ball are given coordinates list of [my team coordinates list, opponent team coordinates list, ball coordinates
list] nested list. Current positions of robots and ball
※ Details are in the table below EOF Bool Marker indicating the end of the frame

Information on ‘my team coordinate list’/’opponent team coordinate list’ number data type explanation 0 robot coordinate list Coordinates of GK robot One robot coordinate list Coordinates of D1 robot 2 robot coordinate list Coordinates of D2 robot 3 robot coordinate list Coordinates of F1 robot 4 robot coordinate list Coordinates of F2 robot Information from ‘robot coordinate list’ number data type explanation 0 float Robot's x coordinate (unit: m) One float Robot's y coordinate (unit: m) 2 float Robot's z coordinate (unit: m) 3 float Orientation of the robot (unit: rad)
※ [-π, π] range, you can check the actual value and convert it to the desired range. 4 Bool An indicator of whether the robot can currently move. Some robots cannot move in special states such as kick-off, corner kick, penalty kick, and goal kick. Also cannot move when ejected. 5 Bool An indicator of whether the robot made contact with the ball in the previous frame.
This value is provided because it is difficult to determine whether the ball and the robot were in contact through coordinates or images. 6 Bool An indicator that indicates whether the ball entered a specific range in front of the robot in the previous frame. You can use this indicator as a basis for kicking the ball Information on ‘ball coordinate list’ number data type explanation 0 double x-coordinate of the ball (unit: m) One double Y coordinate of the ball (unit: m) 2 double z coordinate of the ball (unit: m)

In addition to the robot's ball coordinates and direction, the simulator can provide images. As shown on the top left and right of Figure 23, the provided image is a modified image of 640 x 480 and is provided separately from the game video to enable image-based robot and ball recognition. As shown in Figure 23, the image sent to the gamer code is displayed along with the game frame. The black background shows the stadium floor, the orange shows the soccer ball, and the robot shows an image with a special marker. The image in the upper left corner is sent to team A, and the image in the upper right corner is sent to team B. In other words, strategy code can be implemented using images. Although images can be used to create strategy code, the example code focuses on the coordinates and directions of the robot and ball to simplify the gamer's understanding. The location information of the robot and ball required for AI Soccer is provided as coordinate values, so unless the algorithm is designed using image data, gamers do not need to use image data. The robot has two wheels attached to both sides of the lower body. It can be moved with You can also jump or kick a ball using the sliders attached to the bottom and front of the body. Lastly, dribbling mode can be activated when the robot has the opportunity to dribble. In gamer code, wheel, slider, and dribble mode control is achieved by calling ‘set_speeds()’ at each time step. The ‘set_speeds()’ function is called to transmit the desired wheel, slider, and dribble speed values to the simulator. Each robot has 6 variables. The first variable is related to the speed of the robot's left wheel. The second variable is related to the speed of the robot's right wheel. The third and fourth variables are related to the speed and height of the front slider, respectively. The fifth variable is related to the bottom slider speed. The sixth variable is related to dribbling mode. Tables 6 to 10 show robot control variables. Tables 6 to 10 show the six control variables required for each robot. In Tables 6 to 10, GK means goalkeeper, D1 means defender 1, D2 means defender 2, F1 means attacker 1, and F2 means attacker 2.

[0] [One] [2] [3] [4] [5] data type float float float float float float explanation GK, left wheel speed GK, right wheel speed GK, front slider speed GK, front slider height GK, bottom slider speed GK, switch to dribbling mode

[6] [7] [8] [9] [10] [11] data type float float float float float float explanation D1, left wheel speed D1, right wheel speed D1, front slider
speed D1, front slider
height D1, bottom slider
speed D1, dribbling mode switch

[12] [13] [14] [15] [16] [17] data type float float float float float float explanation D2, left wheel speed D2, right wheel speed D2, front slider
speed D2, front slider
height D2, bottom slider
speed D2, dribbling mode switch

[18] [9] [20] [21] [22] [23] data type float float float float float float explanation F1, left wheel speed F1, right wheel speed F1, front slider speed F1, front slider height F1, bottom slider speed F1, dribble mode switch

[24] [25] [26] [27] [28] [29] data type float float float float float float explanation F2, left wheel speed F2, right wheel speed F2, front slider speed F2, front slider height F2, bottom slider speed F2, toggle dribbling mode

Taking Tables 6 to 10 as an example, by changing the values of [24] and [25], F2 can be made to move. At this time, the values of [24] and [25] change the values of the left wheel and right wheel, respectively. If the two values are positive and have the same size, the robot moves forward at a constant speed. If both values are negative and the magnitudes are the same, the robot moves backwards at a constant speed. If you use a negative number on one side and a positive number on the other side of the same absolute value number, you can control the angle by implementing rotation of the robot in place. By changing the values of [26] and [27], you can adjust the strength and height of the shot, respectively. It was explained earlier that a shot consists of a cross, kick, and pass. In the second picture of Figure 25, the red color on the robot's foot is where the front slider is located. If you change the value of [28], F2 jumps by moving the bottom slider. Once speed values are sent to the simulator, the simulator maintains the same speeds until one of the following occurs: (1) When the gamer code sends new speeds. In this case, the speed is updated accordingly.

(2) When the game enters a special state such as kick-off, corner kick, penalty kick, or goal kick, the speed of all robots is set to 0. Then, when the state starts, the speed of the robot that can move in that state can be updated again. When that state is over, the speed of the robot that was unable to move in that state can be updated again.

(3) When the robot leaves. The robot's speed is set to 0. When the robot returns to the playing field, its speed can be updated.

In the gamer code, you can give the slider speed a value of 0 to 10. To prevent the situation where the sliders stay on, in the simulator program, once the slider speed is above 0, it returns to 0 after a certain period of time and remains at 0 for 1 second. maintain. The height of the front slider can also be set to a value between 0 and 10, but the effect of height adjustment does not appear immediately in the current frame (time step of 50ms), so it is recommended to adjust the height in advance. The front slider is disabled in the opponent's penalty area. Only goalkeepers can kick high in the penalty area. The slider is not visible in the game scene, but the simulator recognizes the slider's position, and when the slider contacts the ball, the ball moves according to physical laws.

Block coding is for beginners without any special software programming skills. The AI soccer code generator using block coding is a web-based framework for creating rule-based and deep learning-based codes for AI soccer. Figure 25 illustrates a web-based AI soccer code generator. It is designed so that people who are not familiar with coding and are just starting to learn about robot soccer can easily create basic strategies. Block coding is a simplification of important functions into blocks when designing AI soccer. The rule-based system is a programming editor implemented based on Google Blockly. Deep learning systems provide several types of reinforcement learning algorithms that can train one or multiple robots to execute the gamer's desired strategy. To use the AI soccer code generator, select one of the rule-based code generation or deep learning-based code generation menu as shown in Figure 25. The recommended internet browser is Google Chrome.

Figure 26 illustrates a rule-based AI soccer code generator. In a rule-based strategy, each of the five robots must be assigned an appropriate action at each time step. In the case of block coding, it consists of tabs that can implement the strategies of a total of five robots, including GK, D1, D2, F1, and F2, depending on the role of the soccer player. The block coding system provides blocks that represent game environment variables and functions. Six variables (left wheel speed, right wheel speed, front slider speed, front slider height, bottom slider speed, and dribble mode) used to control the robot are defined. The left and right wheels of the robot are defined based on the ‘Robot X’ and ‘Robot Y’ variables that indicate where the robot should move. The speed and height of the front slider is defined as a kick, cross, or quick pass movement. The bottom slider is defined by the jump variable. Dribble mode is activated using the dribble variable. The user must define five motion-related variables for each robot at each time step, depending on the current state of the field.

- X position of the robot (required): Destination the robot should move to on the X axis.

- Y position of the robot (required): Destination the robot should move to on the Y axis.

- Robot's Shoot, Cross, Pass variable (optional): Determines whether the robot shoots, kicks, or passes the ball at the current time step. To shoot, set the “shoot” variable to True. To cross, set the “cross” variable to True. If you want to pass, set the “quickpass” variable to True.

- Robot's jump variable (optional): Whether the robot will attempt a jump in the current time step.

- Robot dribbling (optional): Whether the robot will attempt dribbling at the current time step.

As shown in Figure 27, block categories are displayed at the bottom left of the system. The ‘Environment’ category can define variables and functions related to robot soccer games. Another category consists of programming language blocks such as logic blocks, loops, operations, variables and options for creating special functions.

As shown in Figure 28, the ‘Environment indices’ item includes game state and game reset reason (reset_reason). A ‘frame’ dictionary is also included for each time step.

As shown in Figure 29, ‘Environment Constants’ includes constants received during AI soccer game initialization (init()). The Init() function is related to the size of the stadium and the specifications of the robot.

As shown in Figure 30, ‘Environment Variabales’ contains dynamic variables for AI soccer games. This includes the current position of the ball, the expected position of the ball in the future (expected two frames later), and the current positions of the own and opposing team's robots. It is also related to information received from the ‘frame’ dictionary through update() calls at 50ms intervals.

As shown in Figure 31, ‘Environment Functions’ includes the functions necessary to build a strategy.

- Distance: Calculate the distance between two points

- Degree in radians: Convert radians to degrees

- Radians in degrees: Convert degrees to radians

- ball_is_own: Returns True or False if the ball belongs to my team, if the ball is in my zone, if the ball is in my penalty zone, or if the ball is in a specific zone of my field.

- ball_is_opp: Returns True or False if the ball is owned by the opposing team, if the ball is in the opponent's zone, if the ball is in the opponent's penalty zone, or if the ball is in a specific area of the opponent's field.

- Get attack angle: Calculate the angle between the ball's position and the opponent's goal.

- Get defense angle: Calculate the angle between the ball's location and our team's goal.

- Print: Prints messages to the Webots simulator console for debugging.

The Python programming language used to strengthen the strategy is as follows. The Logic category includes if-else(or if-elif-else) statement, comparison statement, and/or statement, not statement, and boolean statement. The Loops category includes loop and while loop. The Math category includes arithmetic, operations (+, -, The Lists category includes blocks for list creation and also includes blocks for list operations. The Variables category is used to define your own variables. Gamers can define new variables, set them or change them as desired. The Functions category is used to define your own functions. You can define new functions and apply them to your own strategies.

As shown in Figure 32, the example code begins by setting the variables ‘kick’ and ‘jump’ to False. The robots kick or jump in a specific situation, and the code starts by setting the variables ‘kick’ and ‘jump’ to False. Then, the robot has rules for four different situations in the game.

1. If the ball is in his team's penalty area, the robot waits at the stadium coordinates (-0.5, -1) until the other robot takes action.

2. If the ball is in an area other than its own half or penalty area, the robot takes action to chase the ball and attempts to move the ball from its current location to another location.

3. If the ball is in the opponent's camp, the robot takes action to chase the ball. If it has BALL_POSSESSION (ball possession means the robot is close to the ball and has a high probability of successfully kicking it), it attempts a kick motion. The following four high-level behaviors are defined for rule-based block coding.

1. ‘Kick’: If set to True, perform a low kick motion.

2. ‘Cross’: If set to True, performs a high kick movement that makes the ball float.

3. ‘quickpass’: Perform pass if set to True

4. ‘jump’: If set to True, jump is performed.

How to use these operations in gamer code is shown in Figure 33.

When using the generated code, as shown in Figure 34, clicking 'Generate Code' at the bottom of the screen will download the compressed file 'mystrategy.zip'. After extracting the archive, navigate to the simulator's examples folder (or the folder where you implemented the previous strategy). In the config.json file, change team_a or team_b to “executable” and then change rule-based “config/my strategy/main.py” or deep learning-based “examples/mystrategy/train.py”.

The position and direction values of the robot and ball are provided before the game starts. As shown in Figure 35, all coordinates are expressed in units of m along the Cartesian coordinate system. The direction angle is 0 when facing right and is expressed in radians counterclockwise. All coordinate units are meters, and directional angles are expressed in radians from -π to π. As shown in the left part of Figure 35, the direction of the robot is defined by the direction of the arrow that the robot is looking at. The left robot is looking in the 90° or π/2 radian direction, and the right robot is looking in the 0° or 0 radian direction. Figure 36 illustrates field section names of the stadium. AI Soccer is a 5:5 robot soccer game where each team consists of 1 goalkeeper, 2 defenders and 2 attackers, with Team A being a red robot initially positioned on the left side of the pitch and Team B being a blue robot initially positioned on the right side of the pitch. Located. The game lasts 5 minutes each in two halves, and the first half begins with Team A's kickoff. When the second half begins, the positions are switched so that Team A is on the right and Team B is on the left. The second half begins with team B's kickoff. A goal occurs when the center of the ball passes through the goalpost and the score increases accordingly. After a goal is scored, the positions of the robot and the ball are reset, and the game resumes with a kickoff for the team that conceded the goal. Robots that operate using algorithms implemented by players may not be able to easily approach the ball and may wander. If all 10 robot players on the field cannot reach the ball, it is called a stalemate. In other words, it means a state in which no changes occur in the stadium. Additionally, unlike regular stadiums, AI soccer stadiums are surrounded by solid walls, so robots can push the ball toward the wall, and multiple robots making the same attempt can create a situation where the ball gets caught between the wall and the robots. The situation can lead to a deadlock. To prevent such deadlocks, the simulator program is configured to detect deadlocks. Participants must understand and program deadlock rules. In AI soccer, a stalemate is defined as a soccer ball moving at a slow speed of less than 0.4 m/s for 4 seconds. Deadlocks are handled differently depending on the region where the deadlock occurs. If a stalemate occurs in one of the four corner areas, the game is restarted with a corner kick. Ball possession for corner kicks is determined as follows: If a team has a large number of robots in the corner area, that team has possession of the ball. If both teams have the same number of robots, the average distance to the ball is calculated, and the team with the smaller average distance has ownership of the ball. If the average distance is the same, the team on the opposite side of the area has possession of the ball. If a deadlock occurs in one of the two penalty areas, the game is restarted with a penalty kick or goal kick. Ball possession for a penalty kick or goal kick is determined as follows: If a team has a large number of robots in the penalty area, that team takes possession of the ball. If both teams have the same number of robots, the average distance to the ball is calculated, and the team with the shorter average distance takes ownership of the ball. If the average distances are the same, the team on the opposite side of the area has possession. If the team opposite the goal in the area has possession of the ball, the game is played as a penalty kick, otherwise, as a goal kick. If a deadlock occurs outside of a corner or penalty area, the game is restarted with the ball relocated to a central location. For simplicity, AI soccer applies fouls only in the penalty area. Limiting the number of robots that can be inside this area, this rule is intended to prevent the defending team from completely blocking the goal or the attacking team from having multiple robots push the ball into the goal. Also, the time a player can be in the opponent's penalty area is limited. This rule is intended to prevent situations where the defending team pushes the attacking team's goalkeeper. Regarding a foul by the defending team, if the ball is in the penalty area, only three robots of the defending team can be in the penalty area. If more than 4 robots are in the area, the game is restarted with a penalty kick for the attacking team. Regarding a foul by the attacking team, if the ball is in the penalty area, only two robots of the attacking team can be in the penalty area. If three or more robots are in the area, the game is restarted with a goal kick by the defending team. The robot can only be in the opposing team's penalty area for one second. If there is more than 1 second, the robot returns to its default position. And the GK can only be outside the penalty area for one second. If there is more than 1 second, the GK returns to the default position. The soccer ball can leave the field through the side of the top of the goal. If the ball goes out, the game is restarted with a goal kick or corner kick. Possession of the ball for a corner kick or goal kick is determined as follows: The team with the fewest robots to touch the ball last before it goes out takes possession (sometimes more than one robot makes the last touch). If the number of robots is the same, the team on that side of the goal has possession of the ball. If the team on that side of the goal has possession of the ball, the game is played with a goal kick, otherwise it is played with a corner kick. Kickoff occurs at the start of the game and after a team has scored a goal. The game begins with the F2 robot of the team that has possession of the ball kicking the ball at the kickoff. During kickoff, no robot other than the F2 robot of the team in possession may move until one of the following occurs: If the ball leaves the center circle or if the ball does not leave the center circle for 3 seconds. Figure 37 illustrates the kickoff formation (ball possession team: A) and Table 11 illustrates the location and direction of the kickoff. When Team B has possession of the ball, the position and direction are rotated by π and the roles of the two teams are swapped.

A team B team G.K. (-3.8, 0.0) π/2 (3.8, 0.0) -π/2 D1 (-2.25, 1.0) 0 (2.25, -1.0) π D2 (-2.25, -1.0) 0 (2.25, 1.0) π F1 (-0.9, 0) 0 (0.65, -0.3) π F2 (0.4, 0) π (0.65, 0.3) π soccer ball (0, 0)

A corner kick occurs after a stalemate or ball out in the corner area, and the game begins with the F2 robot of the team that has possession of the corner kicking the ball. During a corner kick, no robot other than the F2 robot of the team in possession may move until one of the following occurs: - The F2 robot of the team in possession kicks the ball.

- If the ball is not kicked for 3 seconds

Different corner kick robot formations are applied depending on where the corner kick occurs and which team has possession of the ball. In the case of a corner kick by the defending team, if the corner kick occurrence area is toward the goal line of the team that has possession of the ball, a defensive corner kick robot formation is used. Figure 38 illustrates corner kick formation 1 when defending (ball possession team: A), and Table 12 illustrates the position and direction of corner kick formation 1 when defending.

A team B team G.K. (-3.8, 0.0) π/2 (3.8, 0.0) -π/2 D1 (-2.25, 1.0) -π/2 (1.5, -0.45) π D2 (-3.25, 1.0) -π/2 (1.5, 0.45) π F1 (-3.25, 0) 0 (0.5, -0.8) π F2 (-2.75, 2.0) -π/2 (0.5, 0.8) Π soccer ball (-2.75, 1.5)

Figure 39 illustrates corner kick formation 2 when defending (ball possession team: A), and Table 13 illustrates the position and direction of corner kick formation 2 when defending.

A team B team G.K. (-3.8, 0.0) π/2 (3.8, 0.0) -π/2 D1 (-3.25, 1.0) π/2 (1.5, -0.45) π D2 (-2.25, 1.0) π/2 (1.5, 0.45) π F1 (-3.25, 0) 0 (0.5, -0.8) π F2 (-2.75, -2.0) π/2 (0.5, 0.8) π soccer ball (-2.75, -1.5)

When team B has possession of the ball, the position and direction are rotated by π and the roles of the two teams are reversed. In the case of a corner kick by the attacking team, if the corner kick occurrence area is opposite the goal of the team that has possession of the ball, the offensive corner kick robot formation Apply. Figure 40 illustrates corner kick formation 1 (ball possession team: A) during attack, and Table 14 illustrates the location and direction of corner kick formation 1 during attack. Figure 41 illustrates corner kick formation 2 during an attack (ball possession team: A), and Table 15 illustrates the location and direction of corner kick formation 2 during an attack. When Team B has possession of the ball, the position and direction are rotated by π and the roles of the two teams are swapped.

A team B team G.K. (-3.8, 0.0) π/2 (3.8, 0.0) -π/2 D1 (3.25, 1.0) -π/2 (3.25, -0.5) π/2 D2 (2.25, 1.0) -π/2 (3.25, 0.5) π/2 F1 (2.25, 0) 0 (2.25, -0.5) π/2 F2 (2.75, 2.0) -π/2 (2.25, 0.5) π/2 soccer ball (2.75, 1.5)

A team B team G.K. (-3.8, 0.0) π/2 (3.8, 0.0) -π/2 D1 (2.25, -1.0) π/2 (3.25, -0.5) -π/2 D2 (3.25, -1.0) π/2 (3.25, 0.5) -π/2 F1 (2.25, 0) 0 (2.25, -0.5) -π/2 F2 (2.75, -2.0) π/2 (2.25, 0.5) -π/2 soccer ball (2.75, -1.5)

A penalty kick occurs immediately after a stalemate in the penalty area or a penalty area foul. In a penalty kick, the game is restarted with the F2 robot of the team that has possession kicking the ball. During a penalty kick, no robot other than the F2 robot of the team in possession may move until one of the following occurs: - The F2 robot of the team in possession kicks the ball.

- If the ball is not kicked for 3 seconds

Figure 42 illustrates a penalty kick formation (ball possession team: A) and Table 16 illustrates the location and direction of the penalty kick formation. When Team B has possession of the ball, the position and direction are rotated by π and the roles of the two teams are swapped.

A team B team G.K. (-3.8, 0.0) π/2 (3.8, 0.0) -π/2 D1 (0.5, -0.8) 0 (1.5, 0.8) -π/2 D2 (1.0, -0.8) 0 (1.5, 1.05) -π/2 F1 (1.5, -0.8) 0 (1.25, 0.8) -π/2 F2 (2.0, 0) 0 (1.25, 1.05) -π/2 soccer ball (2.95, 0)

A goal kick occurs after a deadlock in the penalty area, a penalty area foul or the ball is out, and the game begins with the GK robot of the team in possession kicking the ball. During a goal kick, no robot other than the GK robot of the team in possession may move until one of the following occurs: - The GK robot of the team in possession kicks the ball.

- If the ball is not kicked for 3 seconds

Figure 43 illustrates a goal kick formation (ball possession team: A) and Table 17 illustrates the location and direction of the goal kick formation. When Team B has possession of the ball, the position and direction are rotated by π and the roles of the two teams are swapped.

A team B team G.K. (-3.8, 0.0) 0 (3.8, 0.0) -π/2 D1 (-2.5, 0.45) 0 (0.5, -0.8) π D2 (-2.5, -0.45) 0 (0.5, 0.8) π F1 (-1.5, 0.8) 0 (-0.5, -0.45) π F2 (-1.5, -0.8) 0 (-0.5, 0.45) π soccer ball (-3.25, 0)

Ball reallocation occurs after a stalemate in the remaining areas, and there are four designated locations. The ball is relocated to one of the four locations closest to its current location. Robots do not relocate. Once the ball is relocated, play resumes and all robots can move immediately. Table 18 illustrates where the ball is relocated.

Position A Position B Position C Position D (-1.5, 1.0) (-1.5, -1.0) (1.5, 1.0) (1.5, -1.0)

Sometimes it happens that the robot falls and cannot get up on its own. If the robot falls and cannot get up within 3 seconds, the robot is taken out of the arena and cannot perform any activities for 5 seconds. Also, in rare cases, the robot may leave the stadium, and in this case, it will be moved outside and put into a state of inactivity for 5 seconds. After 5 seconds, the robot returns to the stadium in the designated location and direction. If another robot or a ball is in a return position, it will remain off the field until that position becomes available. Table 19 illustrates the robot’s return position and direction.

A team B team G.K. (-3.8, 0.0) π/2 (3.8, 0.0) -π/2 D1 (-2.25, 1.0) 0 (2.25, -1.0) π D2 (-2.25, -1.0) 0 (2.25, 1.0) π F1 (-0.65, 0.3) 0 (0.65, -0.3) π F2 (-0.65, -0.3) 0 (0.65, 0.3) π

In one embodiment, the user terminal is a smartphone, smartpad, tablet personal computer, desktop PC, laptop PC, netbook computer, workstation. Workstation, wearable device (e.g. smart glasses, head-mounted-device (HMD), or smart watch), TV box (e.g. Samsung HomeSync™, It may include at least one of Apple TV™, Google TV™), or a game console (e.g. Xbox™, PlayStation™, Switch™). According to various embodiments of the present invention, the user terminal may provide the user with a UI (User Interface) screen for receiving input of the object, the AI algorithm, the input data format, and the behavior pattern from the user through a display device. there is. The user terminal may provide the UI screen using its own data, or may receive and provide data corresponding to the UI screen from a server system. Each of the object, the AI algorithm, the input data format, and the behavior pattern may be included in one UI screen, or each may have an individual UI screen. According to various embodiments of the present invention, the display device may include, for example, a display (e.g., a liquid crystal display (LCD), a light emitting diode (LED) display, an organic light emitting diode (OLED) display provided integrally with an electronic device. Displays, or microelectromechanical systems (MEMS) displays, or electronic paper displays, etc.), LED monitors and LCD monitors, IPTV, Smart TV, LED TV, and LCD TV, or projectors, etc. You can. A network refers to a connection structure that allows information exchange between nodes such as terminals and servers, and includes a telecommunications network, for example, a computer network (e.g., LAN or WAN), It may include the Internet or a telephone network. According to various embodiments of the present invention, a user terminal and a server system may be connected to a network and communicate with each other through wireless or wired communication. Wireless communication may include, for example, LTE, LTE-A, CDMA, WCDMA, UMTS, WiBro, or GSM as a cellular communication protocol. Additionally, wireless communication is short-distance communication and may include, for example, at least one of Wi-Fi, Bluetooth, near field communication (NFC), or global positioning system (GPS). Wired communication may include, for example, at least one of universal serial bus (USB), high definition multimedia interface (HDMI), recommended standard 232 (RS-232), or plain old telephone service (POTS). One embodiment of the present invention may also be implemented in the form of a recording medium containing instructions executable by a computer, such as program modules executed by a computer. Computer-readable media can be any available media that can be accessed by a computer and includes both volatile and non-volatile media, removable and non-removable media. Additionally, computer-readable media may include both computer storage media and communication media. Computer storage media includes both volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Communication media typically includes computer readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave, or other transmission mechanism, and includes any information delivery medium.

The description of the present invention described above is for illustrative purposes, and those skilled in the art will understand that the present invention can be easily modified into other specific forms without changing the technical idea or essential features of the present invention. will be. Therefore, the embodiments described above should be understood in all respects as illustrative and not restrictive. For example, each component described as unitary may be implemented in a distributed manner, and similarly, components described as distributed may also be implemented in a combined form.

The scope of the present invention is indicated by the claims described later rather than the detailed description, and all changes or modified forms derived from the meaning and scope of the claims and their equivalent concepts should be construed as being included in the scope of the present invention. .

Claims (1)

An input module that receives coding blocks written by the user; and
Converting the coding block into a preset programming language to generate an executable code, constructing a game simulation environment based on the environment information and object information included in the executable code, and based on the result data generated during the game simulation process A server system that generates learning data and updates the simulation environment by learning the learning data based on a preset algorithm.
A computer graphics game programming system for artificial intelligence education purposes, including: