system

Abstract

Provide a system. A terminal means for a user to input basic characteristics of a non-player character; a server means for generating a behavior pattern of a non-player character based on the input basic characteristics; a server means for simulating the generated behavioral patterns; a server means for analyzing the simulation results and generating an optimized behavior pattern; and means for implementing the optimized behavioral patterns on a game server.

Description

[Technical Field]

[0001] The technology of the present disclosure relates to a system. [Background technology]

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] In current video games, non-player characters (NPCs) have monotonous behavior patterns and limited interaction with the player. This reduces the game's realism and enjoyment. Furthermore, it takes a great deal of time and effort for developers to manually adjust NPC behavior patterns, making efficient game development difficult. [Means for solving the problem]

[0005] The present invention solves the aforementioned problems by providing a system including a terminal device through which a user inputs basic characteristics of a non-player character; a server device that generates behavioral patterns for the non-player character based on the input basic characteristics; a server device that simulates the generated behavioral patterns; a server device that analyzes the simulation results and generates optimized behavioral patterns; and a device that implements the optimized behavioral patterns on the game server. This allows NPCs to behave more realistically, increasing interaction with users and improving the appeal of the game. Furthermore, the system also improves the efficiency of game development by allowing developers to efficiently adjust NPC behavioral patterns.

[0006] "User" refers to a person who operates the related system or tool and provides input or instructions.

[0007] "Non-player character (NPC)" refers to a computer-controlled character other than the player in a video game.

[0008] "Basic characteristics" refers to the initial setting values ​​required to determine the behavior of a non-player character, such as personality, skills, and reaction speed.

[0009] "Terminal means" refers to a device or system that a user uses to input basic characteristics of a non-player character or to give instructions.

[0010] "Server means" refers to a computer system for generating, simulating, optimizing, and implementing behavioral patterns of non-player characters.

[0011] A "behavior pattern" refers to a series of actions and reactions that define how a non-player character behaves in a game.

[0012] "Simulation" refers to the process of testing generated behavioral patterns in a virtual environment to ensure they function properly.

[0013] "Virtual environment" refers to a computer-simulated environment that recreates the conditions and situations in which a non-player character performs a particular action.

[0014] "Analysis" refers to the process of evaluating the results of a simulation and identifying unnatural behaviors and areas for improvement.

[0015] "Optimization" refers to the process of modifying behavioral patterns based on analytical results to achieve better performance.

[0016] "Game server" refers to the central computer system that manages game data and controls in-game operations.

[0017] "Implementation" refers to the process of incorporating optimized behavioral patterns into the actual game environment. [Brief explanation of the drawings]

[0018] [Figure 1] 1 is a conceptual diagram showing an example of the configuration of a data processing system according to a first embodiment. [Figure 2] 1 is a conceptual diagram showing an example of main functions of a data processing device and a smart device according to a first embodiment. [Figure 3] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a second embodiment. [Figure 4] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and smart glasses according to a second embodiment. [Figure 5] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a third embodiment. [Figure 6] FIG. 11 is a conceptual diagram showing an example of main functions of a data processing device and a headset-type terminal according to a third embodiment. [Figure 7] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a fourth embodiment. [Figure 8] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and a robot according to a fourth embodiment. [Figure 9] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 10] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 11] FIG. 3 is a sequence diagram showing a processing flow of the data processing system according to the first embodiment. [Figure 12] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1. [Figure 13] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system according to the second embodiment when an emotion engine is combined. [Figure 14] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 when an emotion engine is combined. DETAILED DESCRIPTION OF THE INVENTION

[0019] An example of an embodiment of a system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0020] First, the terms used in the following description will be explained.

[0021] In the following embodiments, a coded processor (hereinafter simply referred to as a "processor") may be a single arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be a single type of arithmetic device or a combination of multiple types of arithmetic devices. Examples of arithmetic devices include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), and an APU (Accelerated Processing Unit).

[0022] In the following embodiments, a coded RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a working memory by a processor.

[0023] In the following embodiments, the coded storage is one or more non-volatile storage devices that store various programs, various parameters, etc. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), and magnetic tapes.

[0024] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0025] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0026] [First embodiment]

[0027] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0028] 1, a data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0029] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0030] The smart device 14 includes a computer 36, a reception device 38, an output device 40, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The reception device 38, the output device 40, and the camera 42 are also connected to the bus 52.

[0031] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0032] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0033] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

[0034] FIG. 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0035] 2, in the data processing device 12, a specific process is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific process is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0036] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0037] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0038] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0039] The present invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and then implementing them in a game. Specific embodiments of this system are described below.

[0040] When a user creates an NPC, they first log in to the Real NPC Development Tool using their device. After logging in, the user clicks the "Create a New NPC" button and sets the basic characteristics (e.g., personality, skills, reaction speed). This setting data is sent from the device to the server.

[0041] The server generates an initial behavior pattern based on the received basic characteristics. For example, when creating a brave swordsman NPC, the server assumes actions such as "attack immediately when it finds an enemy" and "support when it finds an ally." The generated behavior pattern is then presented to the user via their device for confirmation.

[0042] Once the user confirms the proposed behavioral patterns, the server then starts the simulation. In this step, a virtual environment is created and how the NPC will behave in the game is tested. For example, a scene in which an NPC "attacks an enemy as soon as it finds one" is recreated in the simulated environment. After the simulation is run, the server analyzes the results and identifies unnatural behaviors and areas for improvement. The analysis results are sent to the device as a report and displayed to the user.

[0043] The user modifies the NPC's behavioral patterns based on the report. For example, they adjust the settings to speed up the "reaction time to finding an enemy." The modified settings are then sent back to the server from the device. The server regenerates and optimizes the behavioral patterns based on the new settings. Once the final behavioral model is generated, it is sent back to the device for user approval.

[0044] Finally, the behavior model approved by the user is uploaded to the game server by the server, and implementation is completed. Once implementation is complete, a completion notification is sent from the server to the device, and a notification of implementation completion is displayed to the user.

[0045] This system allows NPCs to behave more realistically, increasing player interaction and making games more engaging. It also improves game development efficiency by allowing developers to efficiently adjust NPC behavior patterns. For example, a brave swordsman NPC created by a user can realistically battle enemies or support allies in the actual game.

[0046] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, significantly improving the quality and efficiency of game development.

[0047] The processing flow will be explained below.

[0048] Step 1:

[0049] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[0050] Step 2:

[0051] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[0052] Step 3:

[0053] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[0054] Step 4:

[0055] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[0056] Step 5:

[0057] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[0058] Step 6:

[0059] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[0060] Step 7:

[0061] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[0062] Step 8:

[0063] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[0064] Step 9:

[0065] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[0066] Step 10:

[0067] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[0068] Step 11:

[0069] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[0070] Step 12:

[0071] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[0072] Step 13:

[0073] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[0074] Step 14:

[0075] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[0076] Step 15:

[0077] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[0078] Step 16:

[0079] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[0080] Step 17:

[0081] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[0082] Step 18:

[0083] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[0084] Step 19:

[0085] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[0086] Step 20:

[0087] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[0088] Step 21:

[0089] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[0090] Step 22:

[0091] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[0092] Step 23:

[0093] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[0094] Step 24:

[0095] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[0096] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and then implement them in the game.

[0097] Example 1

[0098] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0099] In conventional game development, the process of creating, simulating, and optimizing behavior patterns for non-player characters (NPCs) is extremely time-consuming and labor-intensive. In particular, it is difficult to detect unnatural behavior and make appropriate corrections based on that information, resulting in a decline in the overall quality of the game. The present invention aims to solve these problems and provide an efficient system for making NPCs behave more realistically.

[0100] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0101] In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, means for identifying unnatural movements and areas for improvement based on the simulation results and sending the results to the user as a report, means for generating a final behavior model based on the user's approval and implementing it on the game server, and means for sending an implementation completion notification to the user. This makes it possible to efficiently generate, simulate, and optimize NPC behavior patterns and immediately implement them in the game.

[0102] A "user" is a user who operates this system and sets the basic characteristics and behavior patterns of non-player characters.

[0103] A "non-player character (NPC)" is a character that is not a player in a game and whose actions are controlled by a program.

[0104] "Basic characteristics" are basic attributes that determine the behavior of a character, such as the personality, skills, and reaction speed of a non-player character.

[0105] "Terminal means" refers to a device that a user uses to modify the settings and behavior patterns of non-player characters, and includes a personal computer, tablet, smartphone, etc.

[0106] "Server means" is a central processing unit for generating, simulating, analyzing, and optimizing behavior patterns of non-player characters.

[0107] A "virtual environment" is a simulated real-world environment created for the purpose of testing and simulating the behavioral patterns of non-player characters.

[0108] A "behavior pattern" is a set of actions and reactions that determine how a non-player character will behave in a particular situation.

[0109] "Simulation" is the process of testing how the behavioral patterns of non-player characters will function within a virtual environment.

[0110] The "report" is a report summarizing the results of analyzing the simulation results and identifying unnatural behaviors and areas for improvement.

[0111] A "final behavior model" is a behavior pattern of a non-player character that has been optimized after receiving user approval and is implemented on the game server.

[0112] A "game server" is a server that executes the actions of non-player characters in a game using a final behavior model.

[0113] The "implementation completion notification" is a notification to inform the user that the final behavior model has been correctly applied to the game server.

[0114] This invention relates to a system for automatically generating behavioral patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. This system streamlines the process for users to create and optimize NPCs, enabling more realistic NPC behavior in games.

[0115] Hardware and software used

[0116] Hardware:

[0117] User devices: PCs, tablets, smartphones, etc.

[0118] Server: Server equipment as a central processing unit

[0119] software:

[0120] Real NPC Development Tool: Software for setting and modifying basic characteristics of NPCs

[0121] Simulation engine: Software for simulating NPC behavior patterns in a virtual environment

[0122] Game Server: Software for implementing the final behavior model in the game

[0123] Data processing and calculation details

[0124] 1. User logs in

[0125] The user logs in to the Real NPC Development Tool using a terminal. After entering their ID and password and successfully logging in, the main menu is displayed.

[0126] 2. Setting NPC basic characteristics

[0127] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[0128] Example: A user sets "Personality: Brave", "Skill: Swordsmanship", and "Reaction Speed: Fast".

[0129] 3. Sending the setting data

[0130] The terminal sends configuration data to the server, which includes the basic characteristics of the NPCs that the user has configured.

[0131] 4. Generation of initial behavioral patterns

[0132] The server uses an AI model to generate initial behavioral patterns based on the received basic characteristic data.

[0133] Example: The server generates behavioral patterns such as "attack immediately when you find an enemy" or "support when you find an ally."

[0134] 5. Presenting and confirming behavioral patterns

[0135] The generated behavioral patterns are displayed on the terminal and the user is asked to confirm them. The user can then confirm the behavioral patterns and request corrections if necessary.

[0136] 6. Running the Simulation

[0137] The server simulates the behavior patterns in a virtual environment, where you can see how the NPCs actually perform the behaviors you set.

[0138] Example: In a virtual environment, a scene is recreated in which an NPC "attacks immediately when it finds an enemy."

[0139] 7. Analysis of Simulation Results

[0140] The server analyzes the results of the simulation and identifies unnatural behavior and areas for improvement.

[0141] Example: A server detects issues such as "slow response times."

[0142] 8. Sending and Viewing Reports

[0143] The server sends the analysis results to the terminal as a report, and the user can use this report to check for changes to the NPC's behavior patterns.

[0144] 9. Modifying Behavioral Patterns

[0145] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[0146] Example: A user makes a modification such as "speed up reaction time."

[0147] 10. Sending corrected data and regenerating behavioral patterns

[0148] Upon receiving the modified data sent from the terminal, the server regenerates a new behavioral pattern.

[0149] 11. Presentation and approval of the final behavioral model

[0150] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[0151] 12. Implementation of the Final Behavioral Model

[0152] The server uploads the approved final behavior model to the game server and completes the implementation.

[0153] Example: The final model is applied to the game server, and a realistic swordsman NPC appears in the game.

[0154] 13. Sending and Displaying Implementation Completion Notification

[0155] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[0156] Examples of concrete examples and prompts

[0157] Example: A brave swordsman NPC created by the user realistically recreates situations in the actual game where he or she fights enemies or supports allies.

[0158] Example of a prompt: Input to the generation AI model, "Generate the behavior pattern of a brave swordsman. Example: Attack immediately when you find an enemy, and support when you find an ally."

[0159] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, which is expected to significantly improve the quality and efficiency of game development.

[0160] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0161] Step 1:

[0162] The user logs in to the Real NPC Development Tool using a terminal. The user enters their ID and password to access the system. If login is successful, the main menu will be displayed.

[0163] Input: ID and password

[0164] Output: Display main menu

[0165] Specific operation: The user enters their ID and password and clicks the "Login" button.

[0166] Step 2:

[0167] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[0168] Input: Basic characteristics such as personality, skills, and reaction speed

[0169] Output: Basic characteristic data

[0170] Specific operation: The user sets basic characteristics for each field, such as "personality: brave," "skill: swordsmanship," and "reaction speed: fast."

[0171] Step 3:

[0172] The device sends configuration data to the server, which includes the basic characteristics of the NPCs configured by the user.

[0173] Input: Basic characteristic data

[0174] Output: Notify the server that data has been sent

[0175] Specific operation: The terminal clicks the "Send" button to send the user's input data to the server.

[0176] Step 4:

[0177] Based on the basic characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[0178] Input: Basic characteristic data

[0179] Output: Initial behavior pattern

[0180] Specific operation: The server inputs a prompt such as "Please generate the behavior pattern of a brave swordsman" into the generated AI model, and obtains behavior patterns such as "attack immediately when an enemy is found" and "support when an ally is found" from the model.

[0181] Step 5:

[0182] The generated behavioral patterns are sent to the terminal and the user is asked to confirm them. The user can then confirm the presented behavioral patterns and request corrections if necessary.

[0183] Input: Initial behavior pattern

[0184] Output: Present behavioral patterns to the user

[0185] Specific operation: The device displays the behavior pattern along with the message "Please check your behavior pattern."

[0186] Step 6:

[0187] The server simulates the behavior patterns in a virtual environment, and the simulation confirms how the NPCs would actually perform the set actions.

[0188] Input: Behavioral pattern

[0189] Output: Simulation results

[0190] Specific operation: The server starts the virtual environment and recreates a scene in which the NPC "attacks immediately when it finds an enemy."

[0191] Step 7:

[0192] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[0193] Input: Simulation results

[0194] Output: Analysis report

[0195] Specific operation: The server analyzes the simulation log and detects problems such as "slow response time."

[0196] Step 8:

[0197] The server sends the analysis results to the device as a report, and the user can use this report to determine how to modify the NPC's behavior patterns.

[0198] Input: Analysis Report

[0199] Output: Report sent to terminal

[0200] Specific operation: The server sends the generated report to the terminal and displays a notification to the user saying "Please check the report."

[0201] Step 9:

[0202] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[0203] Input: Correction property data

[0204] Output: Notification of completion of sending corrected characteristic data

[0205] Specific action: The user makes a correction, such as "speeding up the response time," and clicks the "Submit" button.

[0206] Step 10:

[0207] The terminal sends the modified data to the server, and the server recreates the new behavioral pattern.

[0208] Input: Correction property data

[0209] Output: Regenerated behavior pattern

[0210] Specific operation: The server inputs new data into the generative AI model to generate optimized behavioral patterns.

[0211] Step 11:

[0212] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[0213] Input: Final behavior pattern

[0214] Output: Request for approval from user

[0215] Specific behavior: The device will display a notification saying "Please confirm and approve the final behavior pattern."

[0216] Step 12:

[0217] The server uploads the approved final behavior model to the game server, completing the implementation.

[0218] Input: Final behavior model

[0219] Output: Implementation completion notification to the game server

[0220] Specific operation: The server transfers the final behavior model to the game server and completes the implementation process.

[0221] Step 13:

[0222] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[0223] Input: Implementation completion information

[0224] Output: Notification to the user that implementation is complete

[0225] Specific behavior: The device displays the message "Implementation completed" to the user.

[0226] (Application example 1)

[0227] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0228] Designing and optimizing the behavior patterns of current non-player characters (NPCs) and industrial robots requires a significant amount of time and effort. Furthermore, manual configuration and debugging are prone to human error, reducing overall efficiency. Furthermore, analyzing simulation results and reconfiguring them to appropriate behavior patterns requires specialized knowledge, resulting in a lack of versatility. These issues make it difficult to achieve natural and efficient behavior for NPCs and industrial robots.

[0229] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0230] In this invention, the server includes terminal means for a user to input basic characteristics of a non-player character or an industrial robot, server means for generating behavior patterns of the non-player character or the industrial robot based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, and means for implementing the optimized behavior patterns in a game server or an industrial system. This allows users to easily design, optimize, and implement behavior patterns of NPCs and industrial robots, enabling them to perform efficient and natural movements.

[0231] "Terminal means" refers to a device used by a user to make settings or input data, such as a smartphone, a personal computer, or a factory control terminal.

[0232] "Server means" refers to a computer system that runs on a cloud or local server and processes, simulates, analyzes, and optimizes data.

[0233] "Behavior pattern" refers to a set of rules or algorithms that define the movements or behavior of a non-player character or industrial robot.

[0234] "Simulation" refers to the process of recreating and testing the behavioral patterns of non-player characters or industrial robots within a virtual environment.

[0235] "Optimization" refers to the process of improving inefficient or unnatural behavior based on simulation results and generating more appropriate behavioral patterns.

[0236] A "game server" refers to a server that centrally manages in-game information and processing and processes data for players and NPCs.

[0237] "Industrial systems" refers to all systems used in factories for production lines, robot control, data management, etc.

[0238] "Non-player character (NPC)" refers to a character in a game that is not controlled by the player and behaves according to programmed actions.

[0239] An "industrial robot" refers to a mechanical device that can automatically perform tasks in the production process within a factory.

[0240] The system for carrying out the present invention comprises a user terminal means, a server means, a simulation means, an optimization means, and an implementation means. A specific embodiment of the system will be described below.

[0241] First, the user logs into the system using a dedicated device (e.g., smartphone, PC, factory control terminal). After logging in, the user clicks the "Set new movement pattern" button and inputs the basic characteristics of the target non-player character (NPC) or industrial robot (e.g., movement speed, priority of various tasks, etc.). This setting data is sent from the device to the server.

[0242] The server generates an initial behavioral pattern based on the received basic characteristics. This process uses machine learning frameworks such as TENSORFLOW (registered trademark) and PyTorch. For example, an industrial robot's behavioral pattern may include the action of "picking up packages from a conveyor belt and placing them on a pallet." The server generates this behavior sequence and simulates it in a virtual environment.

[0243] Simulation is the process of testing how generated behavioral patterns perform within a virtual environment. Once the simulation is complete, the simulation results are sent to a server, which analyzes the results and identifies unnatural behaviors or lack of efficiency. This analysis is performed by machine learning algorithms.

[0244] Next, the server modifies and optimizes the movement pattern based on the analysis results. For example, modifications such as "reducing the time it takes to pick up luggage" or "optimizing the speed of movement" are made. The optimized movement pattern is saved again on the server and the user is asked to confirm it.

[0245] Once the user approves the optimized motion pattern, the implementation means uploads the final behavior model to the game server or industrial system, and the implementation is completed, allowing the non-player characters and industrial robots to behave efficiently and naturally.

[0246] This system allows users to easily design, optimize, and implement behavior patterns for NPCs and industrial robots. As a concrete example, the following prompt sentences can be used:

[0247] Example prompt sentence:

[0248] "Start a simulation for the configuration where you want to optimize the robot's motion pattern. The robot will pick items and place them on a pallet. You want to reduce the time from start to finish."

[0249] When this prompt is sent to the server, a machine learning algorithm identifies areas for improvement in behavior and generates optimized patterns. The hardware used includes user devices (smartphones, PCs, factory control terminals), servers (cloud or local servers), and industrial robots (ARM-type robots, etc.). The software used includes server-side scripts (Python or JavaScript®), machine learning frameworks (TensorFlow, PyTorch), and front-end frameworks (React, Vue.js).

[0250] The implementation of this system is expected to significantly improve the efficiency of industrial production lines and the realism of in-game NPCs.

[0251] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0252] Step 1:

[0253] A user logs in to the system using a terminal.

[0254] (Input) User authentication information (user ID, password)

[0255] (Output) Login success message and system home screen

[0256] (Specific operation) The user enters login information into the device and clicks the "Login" button. The device sends the authentication information to the server, which verifies the authentication information and displays the home screen if successful.

[0257] Step 2:

[0258] The user sets a new behavior pattern using the terminal.

[0259] (Input) Basic characteristics of a non-player character or industrial robot (speed of movement, task priority, etc.)

[0260] (Output) Setting data (JSON format, etc.)

[0261] (Specific operation) The user enters the required characteristics on the device's setting screen and clicks the "Save settings" button. The device then sends the entered setting data to the server.

[0262] Step 3:

[0263] The server generates an initial behavior pattern based on the basic characteristics.

[0264] (Input) Setting data

[0265] (Output) Initial behavior pattern (algorithm or rule set)

[0266] (Specific Operation) The server receives the configuration data and generates an initial behavioral pattern using a generative AI model (using TensorFlow or PyTorch). This generated behavioral pattern is, for example, an action sequence of "picking up luggage and placing it on a pallet."

[0267] Step 4:

[0268] The server simulates the generated behavioral patterns in a virtual environment.

[0269] (Input) Initial behavior pattern

[0270] (Output) Simulation results (log files, performance data, etc.)

[0271] (Specific operation) The server creates a virtual environment and executes the initial behavior pattern. At this time, it simulates the robot's behavior in the virtual environment in real time and records the results.

[0272] Step 5:

[0273] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[0274] (Input) Simulation results

[0275] (Output) Analysis results (report and recommended fixes)

[0276] (Specific operation) The server analyzes the simulation log files and performance data, and uses machine learning algorithms to identify unnatural behavior and inefficiencies.

[0277] Step 6:

[0278] The user uses the terminal to check the analysis results and correct the behavioral patterns as necessary.

[0279] (Input) Analysis results, correction parameters

[0280] (Output) Modified behavior pattern

[0281] (Specific operation) The user checks the analysis results displayed on the terminal, and if any corrections are necessary, they input the parameters and reset them. The corrected data is sent back to the server.

[0282] Step 7:

[0283] The server regenerates and optimizes the behavioral patterns based on the modified parameters.

[0284] (Input) Modified parameters

[0285] (Output) Optimized behavioral patterns

[0286] (Specific Operation) The server receives the modified parameters and generates and optimizes the behavioral pattern again. In the optimization process, a simulation is performed again to generate the optimal pattern.

[0287] Step 8:

[0288] The user approves the optimized behavior pattern and the server implements it.

[0289] (Input) Optimized behavioral patterns, user approval

[0290] (Output) Implementation completion notification

[0291] (Specific operation) The user checks the optimized behavior pattern on the device and clicks the "Approve" button. The server uploads the approved behavior pattern to the game server or industrial system and sends a notification of implementation completion to the device.

[0292] Furthermore, an emotion engine that estimates the user's emotion may be combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59 and perform identification processing using the user's emotion.

[0293] This invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. Furthermore, by combining this system with an emotion engine that recognizes the user's emotions and adjusts the NPC's behavior patterns based on those emotions, it provides a more realistic interactive experience.

[0294] First, the user uses the terminal to log in to the game development tool. After logging in, the user clicks the "Create a new NPC" button and sets the basic characteristics of the NPC. For example, the following characteristics can be set:

[0295] Personality: Brave

[0296] Skill: Swordsman

[0297] Reaction speed: Fast

[0298] Once the user sets these basic characteristics, the information is sent from the device to the server. The server uses this data to generate initial behavioral patterns using an AI algorithm. Behavioral scenarios based on the basic characteristics include "attack immediately when an enemy is found" and "support when an ally is found."

[0299] The generated behavioral patterns are then sent to the device and displayed to the user. After the user confirms the behavioral patterns, the server creates a virtual environment and starts the simulation. A specific simulation example is a scene where an NPC encounters an enemy in a virtual combat scenario. Once the simulation is complete, the server analyzes the results, identifies unnatural behaviors and areas for improvement, and generates a report. This report is sent to the device and displayed to the user.

[0300] Based on the report, users can modify the NPC's behavior patterns. For example, they can adjust the settings to speed up the "reaction time to finding an enemy." This modified data is sent back to the server, which then regenerates and optimizes the behavior patterns based on the new settings. After the final behavior model is generated, it is sent back to the device for user approval.

[0301] On the other hand, by using an emotion engine, it is possible to adjust behavioral patterns according to the user's emotional state. Specifically, the emotion engine installed on the device recognizes emotions from the user's facial recognition data and voice tone, and sends this data to the server. The server analyzes the received emotion recognition data and dynamically adjusts behavioral patterns, such as making NPCs more cooperative if the user is feeling stressed.

[0302] As a result, NPCs can better respond to user interactions, improving the game's realism and appeal. For example, if the user is nervous, the NPCs will act more cautiously, and if the user is relaxed, the NPCs will act more boldly.

[0303] Once the final behavioral model is approved by the user, the server uploads it to the game server and completes the implementation. Once the implementation is complete, the results are notified to the device so that the user can check them.

[0304] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic in-game experience, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[0305] The processing flow will be explained below.

[0306] Step 1:

[0307] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[0308] Step 2:

[0309] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[0310] Step 3:

[0311] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[0312] Step 4:

[0313] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[0314] Step 5:

[0315] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[0316] Step 6:

[0317] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[0318] Step 7:

[0319] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[0320] Step 8:

[0321] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[0322] Step 9:

[0323] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[0324] Step 10:

[0325] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[0326] Step 11:

[0327] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[0328] Step 12:

[0329] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[0330] Step 13:

[0331] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[0332] Step 14:

[0333] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[0334] Step 15:

[0335] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[0336] Step 16:

[0337] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[0338] Step 17:

[0339] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[0340] Step 18:

[0341] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[0342] Step 19:

[0343] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[0344] Step 20:

[0345] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[0346] Step 21:

[0347] Emotion Engine: Analyzes the user's face and voice to recognize emotions, determining the user's emotional state in real time.

[0348] Step 22:

[0349] Emotion engine: Sends emotion data to the server. Enables the server to receive emotion data.

[0350] Step 23:

[0351] Server: Dynamically adjusts behavior patterns based on emotion data. Changes NPC behavior according to the user's emotions.

[0352] Step 24:

[0353] Server: Generates the final adjusted behavioral model and sends it to the device. Sends the data so that the user can check it.

[0354] Step 25:

[0355] Terminal: Displays the adjusted behavioral model to the user and asks for approval. Provides an interface for the user to confirm the adjustments.

[0356] Step 26:

[0357] User: Approves the final adjusted behavioral model. Finally, confirms the behavioral model according to the emotion.

[0358] Step 27:

[0359] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[0360] Step 28:

[0361] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[0362] Step 29:

[0363] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[0364] Step 30:

[0365] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[0366] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and emotions, and then implement them in the game.

[0367] Example 2

[0368] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0369] In conventional game systems, the process of generating and optimizing the behavior patterns of non-player characters (NPCs) is often done manually, placing a heavy burden on developers. Furthermore, it is difficult to dynamically adjust NPC behavior based on user emotions, limiting the interactive experience. It is necessary to solve these problems and improve development efficiency and the quality of the game experience.

[0370] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0371] In this invention, the server includes user interface means for allowing a user to input basic characteristics of non-player characters, data processing means for generating behavioral patterns of non-player characters based on the input basic characteristics, data processing means for simulating the generated behavioral patterns, data processing means for analyzing the simulation results and generating optimized behavioral patterns, communication means for implementing the optimized behavioral patterns, and emotion analysis means for recognizing user emotions and dynamically adjusting the behavioral patterns of non-player characters based on that data. This enables dynamic behavior adjustment in response to user emotions, making it possible to provide a realistic and engaging interactive experience while reducing the burden on developers.

[0372] "User interface means" refers to an input device and a display device that allow a user to input basic characteristics and modification parameters of a non-player character.

[0373] "Data processing means" refers to a device that executes algorithms or programs to generate, simulate, analyze and optimize behavioral patterns based on received data.

[0374] "Communication means" refers to the network interface and protocol for uploading and implementing optimized behavioral patterns to the game server.

[0375] "Emotion analysis means" refers to software and hardware for recognizing emotions from a user's facial recognition data and voice tone and analyzing that data.

[0376] "Virtual environment" refers to a simulated environment constructed to test and evaluate the behavioral patterns of non-player characters.

[0377] "Non-player characters" refer to characters that appear in the game and act separately from the user.

[0378] A "behavior pattern" refers to a series of actions or reactions that a non-player character performs in a particular situation.

[0379] "Simulation" refers to the process of replicating the behavioral patterns of non-player characters within a virtual environment and evaluating their actions.

[0380] "Basic characteristics" refers to the initial attributes of a non-player character, such as personality, skills, reaction speed, etc.

[0381] "Parameters" refer to numerical values ​​and settings used to control and adjust the behavior patterns of non-player characters.

[0382] This invention is a system that automatically generates behavior patterns for non-player characters (NPCs) and implements them in a game through simulation and optimization. Furthermore, it combines an emotion engine that recognizes user emotions and dynamically adjusts NPC behavior patterns based on those emotions to provide a more realistic interactive experience. The following describes in detail the embodiments of this invention.

[0383] Hardware and software used

[0384] Hardware:

[0385] Terminal (including user interface means)

[0386] Server (including data processing means and communication means)

[0387] Camera and microphone for emotion analysis (including emotion analysis means)

[0388] software:

[0389] Game Development Tools

[0390] AI algorithms (used for generating and optimizing behavioral patterns)

[0391] Emotion engine (analyzes user emotions)

[0392] Simulation environment construction software

[0393] Specific processing explanation of the system

[0394] User Action:

[0395] First, the user logs in to the game development tool using a terminal. After successfully logging in, the main screen appears and the user clicks the "Create a new NPC" button. The user enters the NPC's basic characteristics (e.g., personality, skills, reaction speed) in the displayed form and clicks the "Submit" button.

[0396] Data transmission and processing:

[0397] The device sends the set characteristic data to the server, which then runs an AI algorithm based on the received characteristic data to generate the NPC's initial behavior pattern. The generated behavior pattern is then sent back to the device and displayed to the user.

[0398] Simulation and optimization:

[0399] The server creates a virtual environment and simulates the generated behavior patterns, such as an NPC encountering an enemy in a virtual combat scenario. The simulation results are analyzed by the server to identify unnatural behaviors and areas for improvement, and a report is generated. This report is sent to the device and displayed to the user.

[0400] Behavioral pattern modification and regeneration:

[0401] The user can then modify the NPC's behavior based on the report and send the modified data back to the server. The server then re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing the behavior. Once the final behavior model is generated, it is sent back to the device for user approval.

[0402] Dynamic adjustment with emotion engine:

[0403] The device runs an emotion engine that analyzes the user's emotions based on facial recognition data, voice tone, etc. The analyzed emotion data is sent to a server, which then dynamically adjusts the NPC's behavior patterns based on the user's emotional state. For example, if the user is stressed, the NPC will behave more cooperatively, and if the user is relaxed, the NPC will behave more boldly.

[0404] Example prompt sentence:

[0405] Generate a new NPC's behavioral pattern. Consider the following characteristics:

[0406] Personality: Brave

[0407] Skill: Swordsman

[0408] Reaction speed: Fast

[0409] Examples of behavioral patterns include 'attack immediately when you spot an enemy' and 'support when you spot an ally.'

[0410] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic interactive experience in the game, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[0411] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0412] Program processing flow

[0413] Step 1: User logs into game development tools

[0414] The user opens the login screen of the game development tool using the terminal, enters the username and password, and clicks the "Login" button.

[0415] Input: Username, Password

[0416] Output: Game development tool main screen

[0417] Operation: If the username and password are successfully authenticated, the main screen will be displayed.

[0418] Step 2: User initiates creation of a new NPC

[0419] The user clicks the "Create a new NPC" button on the main screen.

[0420] Input: "Create New NPC" button click event

[0421] Output: NPC basic characteristics input form

[0422] Effect: A form will appear where you can enter the NPC's basic characteristics.

[0423] Step 3: The device sends the NPC's characteristic data to the server.

[0424] The user inputs the basic characteristics of the NPC (e.g., personality, skills, reaction speed) and clicks the "Send" button. The device then sends this data to the server.

[0425] Input: NPC base characteristic data

[0426] Output: Attribute data sent to the server

[0427] Operation: The device sends the entered characteristic data to the server's API.

[0428] Step 4: The server generates the initial behavior patterns of the NPC.

[0429] Based on the characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[0430] Input: NPC base characteristic data

[0431] Output: Initial behavior pattern

[0432] Behavior: AI algorithms analyze characteristic data and generate behavioral patterns.

[0433] Step 5: The server sends the initial behavior pattern to the terminal and displays it to the user.

[0434] The server transmits the generated behavior pattern to the terminal, and the user confirms the behavior pattern.

[0435] Input: Initial behavior pattern

[0436] Output: Behavioral patterns displayed on the terminal

[0437] Operation: The server sends the behavioral patterns to the device and updates the UI for display.

[0438] Step 6: The server starts the simulation

[0439] After the user confirms their behavioral patterns, the server creates a virtual environment and starts the simulation, for example, simulating an NPC encountering an enemy in a virtual combat scenario.

[0440] Input: Action pattern approval instructions

[0441] Output: Simulation results

[0442] Operation: The server creates a virtual environment and executes a behavioral pattern scenario.

[0443] Step 7: The server analyzes the simulation results and generates a report

[0444] After the simulation is complete, the server analyzes the results, identifies any unusual behaviors and areas for improvement, and generates a report.

[0445] Input: Simulation result data

[0446] Output: Analysis results and reports

[0447] How it works: The server analyzes the resulting data and generates a report.

[0448] Step 8: The server sends the report to the terminal and displays it to the user.

[0449] The server sends the report to the terminal, and the user checks the contents of the report.

[0450] Input: Generated report

[0451] Output: Report displayed on terminal

[0452] What it does: The server sends the report data to the device and updates the UI for display.

[0453] Step 9: User modifies NPC behavior patterns

[0454] The user inputs the parameters of the behavioral pattern that he / she wants to modify based on the report and clicks the "Update" button.

[0455] Input: Correction parameters

[0456] Output: Correction data sent from the device to the server

[0457] Operation: The device sends the modification parameters to the server's API.

[0458] Step 10: The device sends the correction data to the server

[0459] The modified data is transmitted from the terminal to the server and received by the server.

[0460] Input: Correction parameter data

[0461] Output: Modified data stored on the server

[0462] How it works: The device sends correction data via API to the server, which receives and stores the data.

[0463] Step 11: The server recreates and optimizes the behavioral patterns

[0464] The server re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing new behavioral patterns.

[0465] Input: Correction parameter data

[0466] Output: Optimized behavioral patterns

[0467] How it works: The server re-runs the AI ​​algorithms to regenerate and optimize behavioral patterns.

[0468] Step 12: The server sends the final behavior model to the terminal and asks for user approval.

[0469] Once the final behavioral model is generated, the server sends the data to the terminal and asks for the user's approval.

[0470] Input: Optimized behavioral patterns

[0471] Output: Final behavioral model displayed on the terminal

[0472] Operation: The server sends the final behavior model to the device and updates the UI for display.

[0473] Step 13: The device runs the emotion engine and recognizes the user's emotion.

[0474] The emotion engine installed in the device analyzes the user's facial recognition data and voice tone to recognize the user's emotions.

[0475] Input: User's facial recognition data, audio tone

[0476] Output: Sentiment analysis data

[0477] How it works: The device's emotion engine analyzes the input data and identifies the user's emotion.

[0478] Step 14: The server dynamically adjusts behavioral patterns based on emotion data.

[0479] Based on the received emotional data, the server dynamically adjusts the NPC's behavior patterns according to the user's emotional state.

[0480] Input: Sentiment analysis data

[0481] Output: Dynamically adjusted behavioral patterns

[0482] How it works: The server analyzes the sentiment analysis data and adjusts behavioral patterns.

[0483] Step 15: The server uploads the final behavior model to the game server.

[0484] The final behavior model approved by the user is uploaded from the server to the game server.

[0485] Input: Approved Final Behavioral Model

[0486] Output: Behavioral model implemented on the game server

[0487] Operation: The server uploads the behavior model to the game server and completes the implementation.

[0488] Step 16: The device displays a notification to the user that the implementation is complete.

[0489] Once the implementation is complete, the results are notified to the terminal and can be confirmed by the user.

[0490] Input: Implementation Completion Notification

[0491] Output: A completion notification displayed on the terminal

[0492] Action: The device receives a notification that the implementation is complete and displays it to the user.

[0493] (Application example 2)

[0494] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0495] Conventional food delivery services have struggled to provide an experience that takes into account the emotions of customers during delivery. Furthermore, delivery by general autonomous robots lacks the ability to respond appropriately to situations where the customer is tired or relaxed, making it difficult to improve customer satisfaction.

[0496] The identification processing by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, means for implementing the optimized behavior patterns on the game server, server means for recognizing the user's emotions and dynamically adjusting the behavior patterns of non-player characters in accordance with the emotions, and terminal means for recognizing the user's emotions in the autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions. This enables the autonomous delivery robot to respond in accordance with the emotions of customers, providing customers with a personalized delivery experience.

[0497] "Terminal means for the user to input the basic characteristics of a non-player character" refers to a device that allows the user to set the characteristics of a non-player character (NPC), and by which the user can input characteristics such as the personality and skills of the NPC.

[0498] The "server means for generating behavior patterns of non-player characters based on input basic characteristics" is a server for generating behavior patterns of NPCs using an algorithm based on the characteristic information of the NPCs input by the user.

[0499] The "server means for simulating the generated behavior pattern" is a server for running the generated behavior pattern of the NPC on a trial basis in a virtual environment and simulating it.

[0500] The "server means for analyzing the simulation results and generating optimized behavioral patterns" is a server for evaluating and analyzing the simulation results, correcting unnatural or inefficient behaviors, and generating optimized behavioral patterns.

[0501] "Means for implementing optimized behavior patterns on a game server" refers to means for applying optimized NPC behavior patterns within a game and making them operate in an actual game environment.

[0502] "Server means for recognizing the user's emotions and dynamically adjusting the behavioral patterns of non-player characters in accordance with those emotions" refers to a server that analyzes the user's emotional state (for example, through facial recognition or voice recognition) and adjusts the behavior of NPCs in real time based on the results.

[0503] "Terminal means for recognizing the emotions of a user in an autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions" refers to a terminal that allows an autonomous food delivery robot to analyze the emotions of a customer when making a delivery and adjust the robot's behavior and greeting message according to those emotions.

[0504] This invention is a system for food delivery services in which an autonomous delivery robot recognizes the emotions of customers and dynamically adjusts its behavior in response to those emotions. This system includes a terminal means for users to set the behavior patterns of non-player characters (NPCs), a server means for performing simulations and optimization based on those behavior patterns, and a function for recognizing customer emotions and adjusting the behavior of the delivery robot.

[0505] System Configuration

[0506] 1. Terminal means

[0507] The user inputs basic characteristics of the NPC using the terminal means, such as personality, skills, reaction speed, etc.

[0508] 2. Server Means

[0509] The server means generates behavior patterns of the NPC based on the basic characteristics input by the user. The generated behavior patterns are then simulated and the simulation results are analyzed. The server optimizes the behavior patterns of the NPC based on the simulation results. The optimized behavior patterns are finally implemented on the game server.

[0510] 3. Emotion recognition and behavioral regulation

[0511] The server also has the ability to recognize the user's emotions. This is done using facial expression analysis and voice tone analysis. This allows the server to understand the user's state, such as whether they are tired or relaxed. The server dynamically adjusts the behavior of NPCs based on the recognized emotions.

[0512] 4. Delivery robots

[0513] A food delivery robot receives instructions from the server and adjusts its behavior according to the customer's emotions. For example, if the robot detects that the customer is tired, it will deliver quickly and quietly and play a message like, "Thank you for your hard work. Here's your delivery. Please relax." On the other hand, if the customer is relaxed, the robot will deliver at a normal speed and play a message like, "Thank you for your order! We'll deliver it to you soon!"

[0514] Hardware and software used

[0515] Devices: personal computers and smartphones

[0516] Server: High-performance cloud server

[0517] Emotion recognition: facial recognition software (e.g., Emotion API), voice recognition software

[0518] Delivery Robot: Autonomous robot for food delivery

[0519] Generative AI model: Behavioral pattern generation system

[0520] Specific examples

[0521] Scenario 1: A customer receives a delivery after a long day. Emotion recognition software recognizes the customer's facial expression as "tired." The delivery robot plays a message saying, "Thank you for your hard work. Here's your delivery. Please relax." and quietly makes the delivery.

[0522] Scenario 2: A customer is having a good time with friends. The emotion recognition software recognizes the customer's facial expression as "happy." The delivery robot plays a message saying, "Thank you for your order! We'll deliver it to you soon!" and delivers the package at a normal speed.

[0523] Prompt Sentence Examples

[0524] "If the customer's emotion is 'tired,' the robot will deliver quickly and quietly, playing the message, 'Thank you for your hard work. Here's your delivery. Please relax.' If the customer's emotion is 'happy,' the robot will deliver at a normal speed, playing the message, 'Thank you for your order! We'll deliver it to you soon!'"

[0525] The present invention enables the food delivery experience to be highly personalized according to the customer's emotional state, which is expected to improve customer satisfaction.

[0526] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0527] Step 1:

[0528] The terminal allows the user to input the basic characteristics of the non-player character. At this time, the user sets characteristics such as personality, skills, and reaction speed. The terminal receives the input basic characteristics and transmits them to the server. The input data includes "brave," "swordsman," and "fast."

[0529] Step 2:

[0530] The server receives the basic characteristics sent from the device and generates initial behavior patterns for non-player characters based on that information. The server analyzes the input data and generates behavior patterns using an algorithm. The generated behavior patterns include "attack immediately when an enemy is found" and "support when an ally is found."

[0531] Step 3:

[0532] The server constructs a virtual environment to simulate the generated behavioral patterns and starts the simulation. It experimentally reproduces the behavior of non-player characters in the virtual environment and collects the results. The output of the simulation is data including, for example, "attacking an enemy in a battle scenario" and "supporting an ally."

[0533] Step 4:

[0534] The server analyzes the simulation results and identifies unnatural behaviors and areas for improvement. It then organizes the simulation data and generates optimized behavior patterns. For example, this includes adjusting reaction speed and modifying attack patterns to make them more effective. The optimized data is the optimized behavior pattern.

[0535] Step 5:

[0536] The server implements the optimized behavior pattern on the game server. After implementation, these settings are reflected in the game, and the non-player characters behave in the actual game environment. The game server then verifies that the behavior pattern has been applied correctly and notifies the terminal of the result. The output is a notification that "The behavior pattern has been implemented."

[0537] Step 6:

[0538] The device collects data through a camera and microphone to recognize the user's emotions. The collected data is sent to an emotion recognition engine that analyzes the user's facial expressions and voice tone. The input data is video and audio data.

[0539] Step 7:

[0540] The server analyzes the collected facial expression and voice tone data to identify the user's emotional state. For example, emotion recognition software is used to distinguish emotions such as "tired" or "happy." The analysis results in the recognition data such as "The user is tired."

[0541] Step 8:

[0542] The server dynamically adjusts the behavioral patterns of non-player characters based on the recognized emotional state. For example, if the user is tired, it sets the character's behavior to be more cooperative. The output is a message saying "Behavior pattern adjusted."

[0543] Step 9:

[0544] The terminal acquires the camera feed of the autonomous delivery robot and collects data that the robot can use to recognize customer emotions. The collected data is video data.

[0545] Step 10:

[0546] The server analyzes the customer's emotions based on the video data sent from the device. For example, it uses emotion recognition software to distinguish between "tired" and "happy." The analysis result is "The customer is feeling tired."

[0547] Step 11:

[0548] The server adjusts the behavior of the delivery robot based on the analysis results. For example, if the customer is tired, the delivery robot will deliver quickly and quietly and play a message saying, "Thank you for your hard work. Here's your delivery. Please relax." The output is a message saying, "Behavior adjusted."

[0549] This will enable autonomous food delivery robots to respond to customers' emotions, providing a more personalized experience.

[0550] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0551] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0552] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0553] [Second embodiment]

[0554] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0555] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0556] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0557] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, and the camera 42 are also connected to the bus 52.

[0558] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0559] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0560] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0561] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0562] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0563] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0564] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0565] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal."

[0566] The present invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and then implementing them in a game. Specific embodiments of this system are described below.

[0567] When a user creates an NPC, they first log in to the Real NPC Development Tool using their device. After logging in, the user clicks the "Create a New NPC" button and sets the basic characteristics (e.g., personality, skills, reaction speed). This setting data is sent from the device to the server.

[0568] The server generates an initial behavior pattern based on the received basic characteristics. For example, when creating a brave swordsman NPC, the server assumes actions such as "attack immediately when it finds an enemy" and "support when it finds an ally." The generated behavior pattern is then presented to the user via their device for confirmation.

[0569] Once the user confirms the proposed behavioral patterns, the server then starts the simulation. In this step, a virtual environment is created and how the NPC will behave in the game is tested. For example, a scene in which an NPC "attacks an enemy as soon as it finds one" is recreated in the simulated environment. After the simulation is run, the server analyzes the results and identifies unnatural behaviors and areas for improvement. The analysis results are sent to the device as a report and displayed to the user.

[0570] The user modifies the NPC's behavioral patterns based on the report. For example, they adjust the settings to speed up the "reaction time to finding an enemy." The modified settings are then sent back to the server from the device. The server regenerates and optimizes the behavioral patterns based on the new settings. Once the final behavioral model is generated, it is sent back to the device for user approval.

[0571] Finally, the behavior model approved by the user is uploaded to the game server by the server, and implementation is completed. Once implementation is complete, a completion notification is sent from the server to the device, and a notification of implementation completion is displayed to the user.

[0572] This system allows NPCs to behave more realistically, increasing player interaction and making games more engaging. It also improves game development efficiency by allowing developers to efficiently adjust NPC behavior patterns. For example, a brave swordsman NPC created by a user can realistically battle enemies or support allies in the actual game.

[0573] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, significantly improving the quality and efficiency of game development.

[0574] The processing flow will be explained below.

[0575] Step 1:

[0576] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[0577] Step 2:

[0578] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[0579] Step 3:

[0580] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[0581] Step 4:

[0582] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[0583] Step 5:

[0584] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[0585] Step 6:

[0586] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[0587] Step 7:

[0588] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[0589] Step 8:

[0590] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[0591] Step 9:

[0592] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[0593] Step 10:

[0594] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[0595] Step 11:

[0596] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[0597] Step 12:

[0598] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[0599] Step 13:

[0600] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[0601] Step 14:

[0602] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[0603] Step 15:

[0604] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[0605] Step 16:

[0606] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[0607] Step 17:

[0608] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[0609] Step 18:

[0610] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[0611] Step 19:

[0612] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[0613] Step 20:

[0614] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[0615] Step 21:

[0616] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[0617] Step 22:

[0618] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[0619] Step 23:

[0620] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[0621] Step 24:

[0622] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[0623] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and then implement them in the game.

[0624] Example 1

[0625] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0626] In conventional game development, the process of creating, simulating, and optimizing behavior patterns for non-player characters (NPCs) is extremely time-consuming and labor-intensive. In particular, it is difficult to detect unnatural behavior and make appropriate corrections based on that information, resulting in a decline in the overall quality of the game. The present invention aims to solve these problems and provide an efficient system for making NPCs behave more realistically.

[0627] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0628] In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, means for identifying unnatural movements and areas for improvement based on the simulation results and sending the results to the user as a report, means for generating a final behavior model based on the user's approval and implementing it on the game server, and means for sending an implementation completion notification to the user. This makes it possible to efficiently generate, simulate, and optimize NPC behavior patterns and immediately implement them in the game.

[0629] A "user" is a user who operates this system and sets the basic characteristics and behavior patterns of non-player characters.

[0630] A "non-player character (NPC)" is a character that is not a player in a game and whose actions are controlled by a program.

[0631] "Basic characteristics" are basic attributes that determine the behavior of a character, such as the personality, skills, and reaction speed of a non-player character.

[0632] "Terminal means" refers to a device that a user uses to modify the settings and behavior patterns of non-player characters, and includes a personal computer, tablet, smartphone, etc.

[0633] "Server means" is a central processing unit for generating, simulating, analyzing, and optimizing behavior patterns of non-player characters.

[0634] A "virtual environment" is a simulated real-world environment created for the purpose of testing and simulating the behavioral patterns of non-player characters.

[0635] A "behavior pattern" is a set of actions and reactions that determine how a non-player character will behave in a particular situation.

[0636] "Simulation" is the process of testing how the behavioral patterns of non-player characters will function within a virtual environment.

[0637] The "report" is a report summarizing the results of analyzing the simulation results and identifying unnatural behaviors and areas for improvement.

[0638] A "final behavior model" is a behavior pattern of a non-player character that has been optimized after receiving user approval and is implemented on the game server.

[0639] A "game server" is a server that executes the actions of non-player characters in a game using a final behavior model.

[0640] The "implementation completion notification" is a notification to inform the user that the final behavior model has been correctly applied to the game server.

[0641] This invention relates to a system for automatically generating behavioral patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. This system streamlines the process for users to create and optimize NPCs, enabling more realistic NPC behavior in games.

[0642] Hardware and software used

[0643] Hardware:

[0644] User devices: PCs, tablets, smartphones, etc.

[0645] Server: Server equipment as a central processing unit

[0646] software:

[0647] Real NPC Development Tool: Software for setting and modifying basic characteristics of NPCs

[0648] Simulation engine: Software for simulating NPC behavior patterns in a virtual environment

[0649] Game Server: Software for implementing the final behavior model in the game

[0650] Data processing and calculation details

[0651] 1. User logs in

[0652] The user logs in to the Real NPC Development Tool using a terminal. After entering their ID and password and successfully logging in, the main menu is displayed.

[0653] 2. Setting NPC basic characteristics

[0654] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[0655] Example: A user sets "Personality: Brave", "Skill: Swordsmanship", and "Reaction Speed: Fast".

[0656] 3. Sending the setting data

[0657] The terminal sends configuration data to the server, which includes the basic characteristics of the NPCs that the user has configured.

[0658] 4. Generation of initial behavioral patterns

[0659] The server uses an AI model to generate initial behavioral patterns based on the received basic characteristic data.

[0660] Example: The server generates behavioral patterns such as "attack immediately when you find an enemy" or "support when you find an ally."

[0661] 5. Presenting and confirming behavioral patterns

[0662] The generated behavioral patterns are displayed on the terminal and the user is asked to confirm them. The user can then confirm the behavioral patterns and request corrections if necessary.

[0663] 6. Running the Simulation

[0664] The server simulates the behavior patterns in a virtual environment, where you can see how the NPCs actually perform the behaviors you set.

[0665] Example: In a virtual environment, a scene is recreated in which an NPC "attacks immediately when it finds an enemy."

[0666] 7. Analysis of Simulation Results

[0667] The server analyzes the results of the simulation and identifies unnatural behavior and areas for improvement.

[0668] Example: A server detects issues such as "slow response times."

[0669] 8. Sending and Viewing Reports

[0670] The server sends the analysis results to the terminal as a report, and the user can use this report to check for changes to the NPC's behavior patterns.

[0671] 9. Modifying Behavioral Patterns

[0672] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[0673] Example: A user makes a modification such as "speed up reaction time."

[0674] 10. Sending corrected data and regenerating behavioral patterns

[0675] Upon receiving the modified data sent from the terminal, the server regenerates a new behavioral pattern.

[0676] 11. Presentation and approval of the final behavioral model

[0677] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[0678] 12. Implementation of the Final Behavioral Model

[0679] The server uploads the approved final behavior model to the game server and completes the implementation.

[0680] Example: The final model is applied to the game server, and a realistic swordsman NPC appears in the game.

[0681] 13. Sending and Displaying Implementation Completion Notification

[0682] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[0683] Examples of concrete examples and prompts

[0684] Example: A brave swordsman NPC created by the user realistically recreates situations in the actual game where he or she fights enemies or supports allies.

[0685] Example of a prompt: Input to the generation AI model, "Generate the behavior pattern of a brave swordsman. Example: Attack immediately when you find an enemy, and support when you find an ally."

[0686] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, which is expected to significantly improve the quality and efficiency of game development.

[0687] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0688] Step 1:

[0689] The user logs in to the Real NPC Development Tool using a terminal. The user enters their ID and password to access the system. If login is successful, the main menu will be displayed.

[0690] Input: ID and password

[0691] Output: Display main menu

[0692] Specific operation: The user enters their ID and password and clicks the "Login" button.

[0693] Step 2:

[0694] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[0695] Input: Basic characteristics such as personality, skills, and reaction speed

[0696] Output: Basic characteristic data

[0697] Specific operation: The user sets basic characteristics for each field, such as "personality: brave," "skill: swordsmanship," and "reaction speed: fast."

[0698] Step 3:

[0699] The device sends configuration data to the server, which includes the basic characteristics of the NPCs configured by the user.

[0700] Input: Basic characteristic data

[0701] Output: Notify the server that data has been sent

[0702] Specific operation: The terminal clicks the "Send" button to send the user's input data to the server.

[0703] Step 4:

[0704] Based on the basic characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[0705] Input: Basic characteristic data

[0706] Output: Initial behavior pattern

[0707] Specific operation: The server inputs a prompt such as "Please generate the behavior pattern of a brave swordsman" into the generated AI model, and obtains behavior patterns such as "attack immediately when an enemy is found" and "support when an ally is found" from the model.

[0708] Step 5:

[0709] The generated behavioral patterns are sent to the terminal and the user is asked to confirm them. The user can then confirm the presented behavioral patterns and request corrections if necessary.

[0710] Input: Initial behavior pattern

[0711] Output: Present behavioral patterns to the user

[0712] Specific operation: The device displays the behavior pattern along with the message "Please check your behavior pattern."

[0713] Step 6:

[0714] The server simulates the behavior patterns in a virtual environment, and the simulation confirms how the NPCs would actually perform the set actions.

[0715] Input: Behavioral pattern

[0716] Output: Simulation results

[0717] Specific operation: The server starts the virtual environment and recreates a scene in which the NPC "attacks immediately when it finds an enemy."

[0718] Step 7:

[0719] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[0720] Input: Simulation results

[0721] Output: Analysis report

[0722] Specific operation: The server analyzes the simulation log and detects problems such as "slow response time."

[0723] Step 8:

[0724] The server sends the analysis results to the device as a report, and the user can use this report to determine how to modify the NPC's behavior patterns.

[0725] Input: Analysis Report

[0726] Output: Report sent to terminal

[0727] Specific operation: The server sends the generated report to the terminal and displays a notification to the user saying "Please check the report."

[0728] Step 9:

[0729] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[0730] Input: Correction property data

[0731] Output: Notification of completion of sending corrected characteristic data

[0732] Specific action: The user makes a correction, such as "speeding up the response time," and clicks the "Submit" button.

[0733] Step 10:

[0734] The terminal sends the modified data to the server, and the server recreates the new behavioral pattern.

[0735] Input: Correction property data

[0736] Output: Regenerated behavior pattern

[0737] Specific operation: The server inputs new data into the generative AI model to generate optimized behavioral patterns.

[0738] Step 11:

[0739] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[0740] Input: Final behavior pattern

[0741] Output: Request for approval from user

[0742] Specific behavior: The device will display a notification saying "Please confirm and approve the final behavior pattern."

[0743] Step 12:

[0744] The server uploads the approved final behavior model to the game server, completing the implementation.

[0745] Input: Final behavior model

[0746] Output: Implementation completion notification to the game server

[0747] Specific operation: The server transfers the final behavior model to the game server and completes the implementation process.

[0748] Step 13:

[0749] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[0750] Input: Implementation completion information

[0751] Output: Notification to the user that implementation is complete

[0752] Specific behavior: The device displays the message "Implementation completed" to the user.

[0753] (Application example 1)

[0754] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0755] Designing and optimizing the behavior patterns of current non-player characters (NPCs) and industrial robots requires a significant amount of time and effort. Furthermore, manual configuration and debugging are prone to human error, reducing overall efficiency. Furthermore, analyzing simulation results and reconfiguring them to appropriate behavior patterns requires specialized knowledge, resulting in a lack of versatility. These issues make it difficult to achieve natural and efficient behavior for NPCs and industrial robots.

[0756] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0757] In this invention, the server includes terminal means for a user to input basic characteristics of a non-player character or an industrial robot, server means for generating behavior patterns of the non-player character or the industrial robot based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, and means for implementing the optimized behavior patterns in a game server or an industrial system. This allows users to easily design, optimize, and implement behavior patterns of NPCs and industrial robots, enabling them to perform efficient and natural movements.

[0758] "Terminal means" refers to a device used by a user to make settings or input data, such as a smartphone, a personal computer, or a factory control terminal.

[0759] "Server means" refers to a computer system that runs on a cloud or local server and processes, simulates, analyzes, and optimizes data.

[0760] "Behavior pattern" refers to a set of rules or algorithms that define the movements or behavior of a non-player character or industrial robot.

[0761] "Simulation" refers to the process of recreating and testing the behavioral patterns of non-player characters or industrial robots within a virtual environment.

[0762] "Optimization" refers to the process of improving inefficient or unnatural behavior based on simulation results and generating more appropriate behavioral patterns.

[0763] A "game server" refers to a server that centrally manages in-game information and processing and processes data for players and NPCs.

[0764] "Industrial systems" refers to all systems used in factories for production lines, robot control, data management, etc.

[0765] "Non-player character (NPC)" refers to a character in a game that is not controlled by the player and behaves according to programmed actions.

[0766] An "industrial robot" refers to a mechanical device that can automatically perform tasks in the production process within a factory.

[0767] The system for carrying out the present invention comprises a user terminal means, a server means, a simulation means, an optimization means, and an implementation means. A specific embodiment of the system will be described below.

[0768] First, the user logs into the system using a dedicated device (e.g., smartphone, PC, factory control terminal). After logging in, the user clicks the "Set new movement pattern" button and inputs the basic characteristics of the target non-player character (NPC) or industrial robot (e.g., movement speed, priority of various tasks, etc.). This setting data is sent from the device to the server.

[0769] The server generates an initial behavioral pattern based on the received basic characteristics. This process uses machine learning frameworks such as TensorFlow and PyTorch. For example, an industrial robot's behavioral pattern might include the task of "picking up packages from a conveyor belt and placing them on a pallet." The server generates this behavior sequence and simulates it in a virtual environment.

[0770] Simulation is the process of testing how generated behavioral patterns perform within a virtual environment. Once the simulation is complete, the simulation results are sent to a server, which analyzes the results and identifies unnatural behaviors or lack of efficiency. This analysis is performed by machine learning algorithms.

[0771] Next, the server modifies and optimizes the movement pattern based on the analysis results. For example, modifications such as "reducing the time it takes to pick up luggage" or "optimizing the speed of movement" are made. The optimized movement pattern is saved again on the server and the user is asked to confirm it.

[0772] Once the user approves the optimized motion pattern, the implementation means uploads the final behavior model to the game server or industrial system, and the implementation is completed, allowing the non-player characters and industrial robots to behave efficiently and naturally.

[0773] This system allows users to easily design, optimize, and implement behavior patterns for NPCs and industrial robots. As a concrete example, the following prompt sentences can be used:

[0774] Example prompt sentence:

[0775] "Start a simulation for the configuration where you want to optimize the robot's motion pattern. The robot will pick items and place them on a pallet. You want to reduce the time from start to finish."

[0776] When this prompt is sent to the server, a machine learning algorithm identifies areas for improvement in behavior and generates optimized patterns.The hardware used includes user devices (smartphones, PCs, factory control terminals), servers (cloud or local servers), and industrial robots (ARM robots, etc.).The software used includes server-side scripts (Python or JavaScript), machine learning frameworks (TensorFlow, PyTorch), and front-end frameworks (React, Vue.js).

[0777] The implementation of this system is expected to significantly improve the efficiency of industrial production lines and the realism of in-game NPCs.

[0778] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0779] Step 1:

[0780] A user logs in to the system using a terminal.

[0781] (Input) User authentication information (user ID, password)

[0782] (Output) Login success message and system home screen

[0783] (Specific operation) The user enters login information into the device and clicks the "Login" button. The device sends the authentication information to the server, which verifies the authentication information and displays the home screen if successful.

[0784] Step 2:

[0785] The user sets a new behavior pattern using the terminal.

[0786] (Input) Basic characteristics of a non-player character or industrial robot (speed of movement, task priority, etc.)

[0787] (Output) Setting data (JSON format, etc.)

[0788] (Specific operation) The user enters the required characteristics on the device's setting screen and clicks the "Save settings" button. The device then sends the entered setting data to the server.

[0789] Step 3:

[0790] The server generates an initial behavior pattern based on the basic characteristics.

[0791] (Input) Setting data

[0792] (Output) Initial behavior pattern (algorithm or rule set)

[0793] (Specific Operation) The server receives the configuration data and generates an initial behavioral pattern using a generative AI model (using TensorFlow or PyTorch). This generated behavioral pattern is, for example, an action sequence of "picking up luggage and placing it on a pallet."

[0794] Step 4:

[0795] The server simulates the generated behavioral patterns in a virtual environment.

[0796] (Input) Initial behavior pattern

[0797] (Output) Simulation results (log files, performance data, etc.)

[0798] (Specific operation) The server creates a virtual environment and executes the initial behavior pattern. At this time, it simulates the robot's behavior in the virtual environment in real time and records the results.

[0799] Step 5:

[0800] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[0801] (Input) Simulation results

[0802] (Output) Analysis results (report and recommended fixes)

[0803] (Specific operation) The server analyzes the simulation log files and performance data, and uses machine learning algorithms to identify unnatural behavior and inefficiencies.

[0804] Step 6:

[0805] The user uses the terminal to check the analysis results and correct the behavioral patterns as necessary.

[0806] (Input) Analysis results, correction parameters

[0807] (Output) Modified behavior pattern

[0808] (Specific operation) The user checks the analysis results displayed on the terminal, and if any corrections are necessary, they input the parameters and reset them. The corrected data is sent back to the server.

[0809] Step 7:

[0810] The server regenerates and optimizes the behavioral patterns based on the modified parameters.

[0811] (Input) Modified parameters

[0812] (Output) Optimized behavioral patterns

[0813] (Specific Operation) The server receives the modified parameters and generates and optimizes the behavioral pattern again. In the optimization process, a simulation is performed again to generate the optimal pattern.

[0814] Step 8:

[0815] The user approves the optimized behavior pattern and the server implements it.

[0816] (Input) Optimized behavioral patterns, user approval

[0817] (Output) Implementation completion notification

[0818] (Specific operation) The user checks the optimized behavior pattern on the device and clicks the "Approve" button. The server uploads the approved behavior pattern to the game server or industrial system and sends a notification of implementation completion to the device.

[0819] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0820] This invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. Furthermore, by combining this system with an emotion engine that recognizes the user's emotions and adjusts the NPC's behavior patterns based on those emotions, it provides a more realistic interactive experience.

[0821] First, the user uses the terminal to log in to the game development tool. After logging in, the user clicks the "Create a new NPC" button and sets the basic characteristics of the NPC. For example, the following characteristics can be set:

[0822] Personality: Brave

[0823] Skill: Swordsman

[0824] Reaction speed: Fast

[0825] Once the user sets these basic characteristics, the information is sent from the device to the server. The server uses this data to generate initial behavioral patterns using an AI algorithm. Behavioral scenarios based on the basic characteristics include "attack immediately when an enemy is found" and "support when an ally is found."

[0826] The generated behavioral patterns are then sent to the device and displayed to the user. After the user confirms the behavioral patterns, the server creates a virtual environment and starts the simulation. A specific simulation example is a scene where an NPC encounters an enemy in a virtual combat scenario. Once the simulation is complete, the server analyzes the results, identifies unnatural behaviors and areas for improvement, and generates a report. This report is sent to the device and displayed to the user.

[0827] Based on the report, users can modify the NPC's behavior patterns. For example, they can adjust the settings to speed up the "reaction time to finding an enemy." This modified data is sent back to the server, which then regenerates and optimizes the behavior patterns based on the new settings. After the final behavior model is generated, it is sent back to the device for user approval.

[0828] On the other hand, by using an emotion engine, it is possible to adjust behavioral patterns according to the user's emotional state. Specifically, the emotion engine installed on the device recognizes emotions from the user's facial recognition data and voice tone, and sends this data to the server. The server analyzes the received emotion recognition data and dynamically adjusts behavioral patterns, such as making NPCs more cooperative if the user is feeling stressed.

[0829] As a result, NPCs can better respond to user interactions, improving the game's realism and appeal. For example, if the user is nervous, the NPCs will act more cautiously, and if the user is relaxed, the NPCs will act more boldly.

[0830] Once the final behavioral model is approved by the user, the server uploads it to the game server and completes the implementation. Once the implementation is complete, the results are notified to the device so that the user can check them.

[0831] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic in-game experience, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[0832] The processing flow will be explained below.

[0833] Step 1:

[0834] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[0835] Step 2:

[0836] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[0837] Step 3:

[0838] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[0839] Step 4:

[0840] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[0841] Step 5:

[0842] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[0843] Step 6:

[0844] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[0845] Step 7:

[0846] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[0847] Step 8:

[0848] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[0849] Step 9:

[0850] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[0851] Step 10:

[0852] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[0853] Step 11:

[0854] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[0855] Step 12:

[0856] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[0857] Step 13:

[0858] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[0859] Step 14:

[0860] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[0861] Step 15:

[0862] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[0863] Step 16:

[0864] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[0865] Step 17:

[0866] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[0867] Step 18:

[0868] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[0869] Step 19:

[0870] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[0871] Step 20:

[0872] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[0873] Step 21:

[0874] Emotion Engine: Analyzes the user's face and voice to recognize emotions, determining the user's emotional state in real time.

[0875] Step 22:

[0876] Emotion engine: Sends emotion data to the server. Enables the server to receive emotion data.

[0877] Step 23:

[0878] Server: Dynamically adjusts behavior patterns based on emotion data. Changes NPC behavior according to the user's emotions.

[0879] Step 24:

[0880] Server: Generates the final adjusted behavioral model and sends it to the device. Sends the data so that the user can check it.

[0881] Step 25:

[0882] Terminal: Displays the adjusted behavioral model to the user and asks for approval. Provides an interface for the user to confirm the adjustments.

[0883] Step 26:

[0884] User: Approves the final adjusted behavioral model. Finally, confirms the behavioral model according to the emotion.

[0885] Step 27:

[0886] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[0887] Step 28:

[0888] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[0889] Step 29:

[0890] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[0891] Step 30:

[0892] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[0893] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and emotions, and then implement them in the game.

[0894] Example 2

[0895] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0896] In conventional game systems, the process of generating and optimizing the behavior patterns of non-player characters (NPCs) is often done manually, placing a heavy burden on developers. Furthermore, it is difficult to dynamically adjust NPC behavior based on user emotions, limiting the interactive experience. It is necessary to solve these problems and improve development efficiency and the quality of the game experience.

[0897] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0898] In this invention, the server includes user interface means for allowing a user to input basic characteristics of non-player characters, data processing means for generating behavioral patterns of non-player characters based on the input basic characteristics, data processing means for simulating the generated behavioral patterns, data processing means for analyzing the simulation results and generating optimized behavioral patterns, communication means for implementing the optimized behavioral patterns, and emotion analysis means for recognizing user emotions and dynamically adjusting the behavioral patterns of non-player characters based on that data. This enables dynamic behavior adjustment in response to user emotions, making it possible to provide a realistic and engaging interactive experience while reducing the burden on developers.

[0899] "User interface means" refers to an input device and a display device that allow a user to input basic characteristics and modification parameters of a non-player character.

[0900] "Data processing means" refers to a device that executes algorithms or programs to generate, simulate, analyze and optimize behavioral patterns based on received data.

[0901] "Communication means" refers to the network interface and protocol for uploading and implementing optimized behavioral patterns to the game server.

[0902] "Emotion analysis means" refers to software and hardware for recognizing emotions from a user's facial recognition data and voice tone and analyzing that data.

[0903] "Virtual environment" refers to a simulated environment constructed to test and evaluate the behavioral patterns of non-player characters.

[0904] "Non-player characters" refer to characters that appear in the game and act separately from the user.

[0905] A "behavior pattern" refers to a series of actions or reactions that a non-player character performs in a particular situation.

[0906] "Simulation" refers to the process of replicating the behavioral patterns of non-player characters within a virtual environment and evaluating their actions.

[0907] "Basic characteristics" refers to the initial attributes of a non-player character, such as personality, skills, reaction speed, etc.

[0908] "Parameters" refer to numerical values ​​and settings used to control and adjust the behavior patterns of non-player characters.

[0909] This invention is a system that automatically generates behavior patterns for non-player characters (NPCs) and implements them in a game through simulation and optimization. Furthermore, it combines an emotion engine that recognizes user emotions and dynamically adjusts NPC behavior patterns based on those emotions to provide a more realistic interactive experience. The following describes in detail the embodiments of this invention.

[0910] Hardware and software used

[0911] Hardware:

[0912] Terminal (including user interface means)

[0913] Server (including data processing means and communication means)

[0914] Camera and microphone for emotion analysis (including emotion analysis means)

[0915] software:

[0916] Game Development Tools

[0917] AI algorithms (used for generating and optimizing behavioral patterns)

[0918] Emotion engine (analyzes user emotions)

[0919] Simulation environment construction software

[0920] Specific processing explanation of the system

[0921] User Action:

[0922] First, the user logs in to the game development tool using a terminal. After successfully logging in, the main screen appears and the user clicks the "Create a new NPC" button. The user enters the NPC's basic characteristics (e.g., personality, skills, reaction speed) in the displayed form and clicks the "Submit" button.

[0923] Data transmission and processing:

[0924] The device sends the set characteristic data to the server, which then runs an AI algorithm based on the received characteristic data to generate the NPC's initial behavior pattern. The generated behavior pattern is then sent back to the device and displayed to the user.

[0925] Simulation and optimization:

[0926] The server creates a virtual environment and simulates the generated behavior patterns, such as an NPC encountering an enemy in a virtual combat scenario. The simulation results are analyzed by the server to identify unnatural behaviors and areas for improvement, and a report is generated. This report is sent to the device and displayed to the user.

[0927] Behavioral pattern modification and regeneration:

[0928] The user can then modify the NPC's behavior based on the report and send the modified data back to the server. The server then re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing the behavior. Once the final behavior model is generated, it is sent back to the device for user approval.

[0929] Dynamic adjustment with emotion engine:

[0930] The device runs an emotion engine that analyzes the user's emotions based on facial recognition data, voice tone, etc. The analyzed emotion data is sent to a server, which then dynamically adjusts the NPC's behavior patterns based on the user's emotional state. For example, if the user is stressed, the NPC will behave more cooperatively, and if the user is relaxed, the NPC will behave more boldly.

[0931] Example prompt sentence:

[0932] Generate a new NPC's behavioral pattern. Consider the following characteristics:

[0933] Personality: Brave

[0934] Skill: Swordsman

[0935] Reaction speed: Fast

[0936] Examples of behavioral patterns include 'attack immediately when you spot an enemy' and 'support when you spot an ally.'

[0937] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic interactive experience in the game, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[0938] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0939] Program processing flow

[0940] Step 1: User logs into game development tools

[0941] The user opens the login screen of the game development tool using the terminal, enters the username and password, and clicks the "Login" button.

[0942] Input: Username, Password

[0943] Output: Game development tool main screen

[0944] Operation: If the username and password are successfully authenticated, the main screen will be displayed.

[0945] Step 2: User initiates creation of a new NPC

[0946] The user clicks the "Create a new NPC" button on the main screen.

[0947] Input: "Create New NPC" button click event

[0948] Output: NPC basic characteristics input form

[0949] Effect: A form will appear where you can enter the NPC's basic characteristics.

[0950] Step 3: The device sends the NPC's characteristic data to the server.

[0951] The user inputs the basic characteristics of the NPC (e.g., personality, skills, reaction speed) and clicks the "Send" button. The device then sends this data to the server.

[0952] Input: NPC base characteristic data

[0953] Output: Attribute data sent to the server

[0954] Operation: The device sends the entered characteristic data to the server's API.

[0955] Step 4: The server generates the initial behavior patterns of the NPC.

[0956] Based on the characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[0957] Input: NPC base characteristic data

[0958] Output: Initial behavior pattern

[0959] Behavior: AI algorithms analyze characteristic data and generate behavioral patterns.

[0960] Step 5: The server sends the initial behavior pattern to the terminal and displays it to the user.

[0961] The server transmits the generated behavior pattern to the terminal, and the user confirms the behavior pattern.

[0962] Input: Initial behavior pattern

[0963] Output: Behavioral patterns displayed on the terminal

[0964] Operation: The server sends the behavioral patterns to the device and updates the UI for display.

[0965] Step 6: The server starts the simulation

[0966] After the user confirms their behavioral patterns, the server creates a virtual environment and starts the simulation, for example, simulating an NPC encountering an enemy in a virtual combat scenario.

[0967] Input: Action pattern approval instructions

[0968] Output: Simulation results

[0969] Operation: The server creates a virtual environment and executes a behavioral pattern scenario.

[0970] Step 7: The server analyzes the simulation results and generates a report

[0971] After the simulation is complete, the server analyzes the results, identifies any unusual behaviors and areas for improvement, and generates a report.

[0972] Input: Simulation result data

[0973] Output: Analysis results and reports

[0974] How it works: The server analyzes the resulting data and generates a report.

[0975] Step 8: The server sends the report to the terminal and displays it to the user.

[0976] The server sends the report to the terminal, and the user checks the contents of the report.

[0977] Input: Generated report

[0978] Output: Report displayed on terminal

[0979] What it does: The server sends the report data to the device and updates the UI for display.

[0980] Step 9: User modifies NPC behavior patterns

[0981] The user inputs the parameters of the behavioral pattern that he / she wants to modify based on the report and clicks the "Update" button.

[0982] Input: Correction parameters

[0983] Output: Correction data sent from the device to the server

[0984] Operation: The device sends the modification parameters to the server's API.

[0985] Step 10: The device sends the correction data to the server

[0986] The modified data is transmitted from the terminal to the server and received by the server.

[0987] Input: Correction parameter data

[0988] Output: Modified data stored on the server

[0989] How it works: The device sends correction data via API to the server, which receives and stores the data.

[0990] Step 11: The server recreates and optimizes the behavioral patterns

[0991] The server re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing new behavioral patterns.

[0992] Input: Correction parameter data

[0993] Output: Optimized behavioral patterns

[0994] How it works: The server re-runs the AI ​​algorithms to regenerate and optimize behavioral patterns.

[0995] Step 12: The server sends the final behavior model to the terminal and asks for user approval.

[0996] Once the final behavioral model is generated, the server sends the data to the terminal and asks for the user's approval.

[0997] Input: Optimized behavioral patterns

[0998] Output: Final behavioral model displayed on the terminal

[0999] Operation: The server sends the final behavior model to the device and updates the UI for display.

[1000] Step 13: The device runs the emotion engine and recognizes the user's emotion.

[1001] The emotion engine installed in the device analyzes the user's facial recognition data and voice tone to recognize the user's emotions.

[1002] Input: User's facial recognition data, audio tone

[1003] Output: Sentiment analysis data

[1004] How it works: The device's emotion engine analyzes the input data and identifies the user's emotion.

[1005] Step 14: The server dynamically adjusts behavioral patterns based on emotion data.

[1006] Based on the received emotional data, the server dynamically adjusts the NPC's behavior patterns according to the user's emotional state.

[1007] Input: Sentiment analysis data

[1008] Output: Dynamically adjusted behavioral patterns

[1009] How it works: The server analyzes the sentiment analysis data and adjusts behavioral patterns.

[1010] Step 15: The server uploads the final behavior model to the game server.

[1011] The final behavior model approved by the user is uploaded from the server to the game server.

[1012] Input: Approved Final Behavioral Model

[1013] Output: Behavioral model implemented on the game server

[1014] Operation: The server uploads the behavior model to the game server and completes the implementation.

[1015] Step 16: The device displays a notification to the user that the implementation is complete.

[1016] Once the implementation is complete, the results are notified to the terminal and can be confirmed by the user.

[1017] Input: Implementation Completion Notification

[1018] Output: A completion notification displayed on the terminal

[1019] Action: The device receives a notification that the implementation is complete and displays it to the user.

[1020] (Application example 2)

[1021] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[1022] Conventional food delivery services have struggled to provide an experience that takes into account the emotions of customers during delivery. Furthermore, delivery by general autonomous robots lacks the ability to respond appropriately to situations where the customer is tired or relaxed, making it difficult to improve customer satisfaction.

[1023] The identification processing by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, means for implementing the optimized behavior patterns on the game server, server means for recognizing the user's emotions and dynamically adjusting the behavior patterns of non-player characters in accordance with the emotions, and terminal means for recognizing the user's emotions in the autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions. This enables the autonomous delivery robot to respond in accordance with the emotions of customers, providing customers with a personalized delivery experience.

[1024] "Terminal means for the user to input the basic characteristics of a non-player character" refers to a device that allows the user to set the characteristics of a non-player character (NPC), and by which the user can input characteristics such as the personality and skills of the NPC.

[1025] The "server means for generating behavior patterns of non-player characters based on input basic characteristics" is a server for generating behavior patterns of NPCs using an algorithm based on the characteristic information of the NPCs input by the user.

[1026] The "server means for simulating the generated behavior pattern" is a server for running the generated behavior pattern of the NPC on a trial basis in a virtual environment and simulating it.

[1027] The "server means for analyzing the simulation results and generating optimized behavioral patterns" is a server for evaluating and analyzing the simulation results, correcting unnatural or inefficient behaviors, and generating optimized behavioral patterns.

[1028] "Means for implementing optimized behavior patterns on a game server" refers to means for applying optimized NPC behavior patterns within a game and making them operate in an actual game environment.

[1029] "Server means for recognizing the user's emotions and dynamically adjusting the behavioral patterns of non-player characters in accordance with those emotions" refers to a server that analyzes the user's emotional state (for example, through facial recognition or voice recognition) and adjusts the behavior of NPCs in real time based on the results.

[1030] "Terminal means for recognizing the emotions of a user in an autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions" refers to a terminal that allows an autonomous food delivery robot to analyze the emotions of a customer when making a delivery and adjust the robot's behavior and greeting message according to those emotions.

[1031] This invention is a system for food delivery services in which an autonomous delivery robot recognizes the emotions of customers and dynamically adjusts its behavior in response to those emotions. This system includes a terminal means for users to set the behavior patterns of non-player characters (NPCs), a server means for performing simulations and optimization based on those behavior patterns, and a function for recognizing customer emotions and adjusting the behavior of the delivery robot.

[1032] System Configuration

[1033] 1. Terminal means

[1034] The user inputs basic characteristics of the NPC using the terminal means, such as personality, skills, reaction speed, etc.

[1035] 2. Server Means

[1036] The server means generates behavior patterns of the NPC based on the basic characteristics input by the user. The generated behavior patterns are then simulated and the simulation results are analyzed. The server optimizes the behavior patterns of the NPC based on the simulation results. The optimized behavior patterns are finally implemented on the game server.

[1037] 3. Emotion recognition and behavioral regulation

[1038] The server also has the ability to recognize the user's emotions. This is done using facial expression analysis and voice tone analysis. This allows the server to understand the user's state, such as whether they are tired or relaxed. The server dynamically adjusts the behavior of NPCs based on the recognized emotions.

[1039] 4. Delivery robots

[1040] A food delivery robot receives instructions from the server and adjusts its behavior according to the customer's emotions. For example, if the robot detects that the customer is tired, it will deliver quickly and quietly and play a message like, "Thank you for your hard work. Here's your delivery. Please relax." On the other hand, if the customer is relaxed, the robot will deliver at a normal speed and play a message like, "Thank you for your order! We'll deliver it to you soon!"

[1041] Hardware and software used

[1042] Devices: personal computers and smartphones

[1043] Server: High-performance cloud server

[1044] Emotion recognition: facial recognition software (e.g., Emotion API), voice recognition software

[1045] Delivery Robot: Autonomous robot for food delivery

[1046] Generative AI model: Behavioral pattern generation system

[1047] Specific examples

[1048] Scenario 1: A customer receives a delivery after a long day. Emotion recognition software recognizes the customer's facial expression as "tired." The delivery robot plays a message saying, "Thank you for your hard work. Here's your delivery. Please relax." and quietly makes the delivery.

[1049] Scenario 2: A customer is having a good time with friends. The emotion recognition software recognizes the customer's facial expression as "happy." The delivery robot plays a message saying, "Thank you for your order! We'll deliver it to you soon!" and delivers the package at a normal speed.

[1050] Prompt Sentence Examples

[1051] "If the customer's emotion is 'tired,' the robot will deliver quickly and quietly, playing the message, 'Thank you for your hard work. Here's your delivery. Please relax.' If the customer's emotion is 'happy,' the robot will deliver at a normal speed, playing the message, 'Thank you for your order! We'll deliver it to you soon!'"

[1052] The present invention enables the food delivery experience to be highly personalized according to the customer's emotional state, which is expected to improve customer satisfaction.

[1053] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1054] Step 1:

[1055] The terminal allows the user to input the basic characteristics of the non-player character. At this time, the user sets characteristics such as personality, skills, and reaction speed. The terminal receives the input basic characteristics and transmits them to the server. The input data includes "brave," "swordsman," and "fast."

[1056] Step 2:

[1057] The server receives the basic characteristics sent from the device and generates initial behavior patterns for non-player characters based on that information. The server analyzes the input data and generates behavior patterns using an algorithm. The generated behavior patterns include "attack immediately when an enemy is found" and "support when an ally is found."

[1058] Step 3:

[1059] The server constructs a virtual environment to simulate the generated behavioral patterns and starts the simulation. It experimentally reproduces the behavior of non-player characters in the virtual environment and collects the results. The output of the simulation is data including, for example, "attacking an enemy in a battle scenario" and "supporting an ally."

[1060] Step 4:

[1061] The server analyzes the simulation results and identifies unnatural behaviors and areas for improvement. It then organizes the simulation data and generates optimized behavior patterns. For example, this includes adjusting reaction speed and modifying attack patterns to make them more effective. The optimized data is the optimized behavior pattern.

[1062] Step 5:

[1063] The server implements the optimized behavior pattern on the game server. After implementation, these settings are reflected in the game, and the non-player characters behave in the actual game environment. The game server then verifies that the behavior pattern has been applied correctly and notifies the terminal of the result. The output is a notification that "The behavior pattern has been implemented."

[1064] Step 6:

[1065] The device collects data through a camera and microphone to recognize the user's emotions. The collected data is sent to an emotion recognition engine that analyzes the user's facial expressions and voice tone. The input data is video and audio data.

[1066] Step 7:

[1067] The server analyzes the collected facial expression and voice tone data to identify the user's emotional state. For example, emotion recognition software is used to distinguish emotions such as "tired" or "happy." The analysis results in the recognition data such as "The user is tired."

[1068] Step 8:

[1069] The server dynamically adjusts the behavioral patterns of non-player characters based on the recognized emotional state. For example, if the user is tired, it sets the character's behavior to be more cooperative. The output is a message saying "Behavior pattern adjusted."

[1070] Step 9:

[1071] The terminal acquires the camera feed of the autonomous delivery robot and collects data that the robot can use to recognize customer emotions. The collected data is video data.

[1072] Step 10:

[1073] The server analyzes the customer's emotions based on the video data sent from the device. For example, it uses emotion recognition software to distinguish between "tired" and "happy." The analysis result is "The customer is feeling tired."

[1074] Step 11:

[1075] The server adjusts the behavior of the delivery robot based on the analysis results. For example, if the customer is tired, the delivery robot will deliver quickly and quietly and play a message saying, "Thank you for your hard work. Here's your delivery. Please relax." The output is a message saying, "Behavior adjusted."

[1076] This will enable autonomous food delivery robots to respond to customers' emotions, providing a more personalized experience.

[1077] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1078] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1079] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[1080] [Third embodiment]

[1081] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[1082] 5, the data processing system 310 includes the data processing device 12 and a headset type terminal 314. An example of the data processing device 12 is a server.

[1083] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1084] The headset type terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a display 343. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the display 343 are also connected to the bus 52.

[1085] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[1086] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[1087] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1088] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1089] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1090] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1091] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1092] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the headset type terminal 314 will be referred to as the "terminal."

[1093] The present invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and then implementing them in a game. Specific embodiments of this system are described below.

[1094] When a user creates an NPC, they first log in to the Real NPC Development Tool using their device. After logging in, the user clicks the "Create a New NPC" button and sets the basic characteristics (e.g., personality, skills, reaction speed). This setting data is sent from the device to the server.

[1095] The server generates an initial behavior pattern based on the received basic characteristics. For example, when creating a brave swordsman NPC, the server assumes actions such as "attack immediately when it finds an enemy" and "support when it finds an ally." The generated behavior pattern is then presented to the user via their device for confirmation.

[1096] Once the user confirms the proposed behavioral patterns, the server then starts the simulation. In this step, a virtual environment is created and how the NPC will behave in the game is tested. For example, a scene in which an NPC "attacks an enemy as soon as it finds one" is recreated in the simulated environment. After the simulation is run, the server analyzes the results and identifies unnatural behaviors and areas for improvement. The analysis results are sent to the device as a report and displayed to the user.

[1097] The user modifies the NPC's behavioral patterns based on the report. For example, they adjust the settings to speed up the "reaction time to finding an enemy." The modified settings are then sent back to the server from the device. The server regenerates and optimizes the behavioral patterns based on the new settings. Once the final behavioral model is generated, it is sent back to the device for user approval.

[1098] Finally, the behavior model approved by the user is uploaded to the game server by the server, and implementation is completed. Once implementation is complete, a completion notification is sent from the server to the device, and a notification of implementation completion is displayed to the user.

[1099] This system allows NPCs to behave more realistically, increasing player interaction and making games more engaging. It also improves game development efficiency by allowing developers to efficiently adjust NPC behavior patterns. For example, a brave swordsman NPC created by a user can realistically battle enemies or support allies in the actual game.

[1100] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, significantly improving the quality and efficiency of game development.

[1101] The processing flow will be explained below.

[1102] Step 1:

[1103] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[1104] Step 2:

[1105] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[1106] Step 3:

[1107] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[1108] Step 4:

[1109] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[1110] Step 5:

[1111] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[1112] Step 6:

[1113] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[1114] Step 7:

[1115] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[1116] Step 8:

[1117] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[1118] Step 9:

[1119] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[1120] Step 10:

[1121] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[1122] Step 11:

[1123] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[1124] Step 12:

[1125] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[1126] Step 13:

[1127] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[1128] Step 14:

[1129] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[1130] Step 15:

[1131] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[1132] Step 16:

[1133] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[1134] Step 17:

[1135] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[1136] Step 18:

[1137] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[1138] Step 19:

[1139] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[1140] Step 20:

[1141] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[1142] Step 21:

[1143] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[1144] Step 22:

[1145] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[1146] Step 23:

[1147] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[1148] Step 24:

[1149] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[1150] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and then implement them in the game.

[1151] Example 1

[1152] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1153] In conventional game development, the process of creating, simulating, and optimizing behavior patterns for non-player characters (NPCs) is extremely time-consuming and labor-intensive. In particular, it is difficult to detect unnatural behavior and make appropriate corrections based on that information, resulting in a decline in the overall quality of the game. The present invention aims to solve these problems and provide an efficient system for making NPCs behave more realistically.

[1154] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1155] In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, means for identifying unnatural movements and areas for improvement based on the simulation results and sending the results to the user as a report, means for generating a final behavior model based on the user's approval and implementing it on the game server, and means for sending an implementation completion notification to the user. This makes it possible to efficiently generate, simulate, and optimize NPC behavior patterns and immediately implement them in the game.

[1156] A "user" is a user who operates this system and sets the basic characteristics and behavior patterns of non-player characters.

[1157] A "non-player character (NPC)" is a character that is not a player in a game and whose actions are controlled by a program.

[1158] "Basic characteristics" are basic attributes that determine the behavior of a character, such as the personality, skills, and reaction speed of a non-player character.

[1159] "Terminal means" refers to a device that a user uses to modify the settings and behavior patterns of non-player characters, and includes a personal computer, tablet, smartphone, etc.

[1160] "Server means" is a central processing unit for generating, simulating, analyzing, and optimizing behavior patterns of non-player characters.

[1161] A "virtual environment" is a simulated real-world environment created for the purpose of testing and simulating the behavioral patterns of non-player characters.

[1162] A "behavior pattern" is a set of actions and reactions that determine how a non-player character will behave in a particular situation.

[1163] "Simulation" is the process of testing how the behavioral patterns of non-player characters will function within a virtual environment.

[1164] The "report" is a report summarizing the results of analyzing the simulation results and identifying unnatural behaviors and areas for improvement.

[1165] A "final behavior model" is a behavior pattern of a non-player character that has been optimized after receiving user approval and is implemented on the game server.

[1166] A "game server" is a server that executes the actions of non-player characters in a game using a final behavior model.

[1167] The "implementation completion notification" is a notification to inform the user that the final behavior model has been correctly applied to the game server.

[1168] This invention relates to a system for automatically generating behavioral patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. This system streamlines the process for users to create and optimize NPCs, enabling more realistic NPC behavior in games.

[1169] Hardware and software used

[1170] Hardware:

[1171] User devices: PCs, tablets, smartphones, etc.

[1172] Server: Server equipment as a central processing unit

[1173] software:

[1174] Real NPC Development Tool: Software for setting and modifying basic characteristics of NPCs

[1175] Simulation engine: Software for simulating NPC behavior patterns in a virtual environment

[1176] Game Server: Software for implementing the final behavior model in the game

[1177] Data processing and calculation details

[1178] 1. User logs in

[1179] The user logs in to the Real NPC Development Tool using a terminal. After entering their ID and password and successfully logging in, the main menu is displayed.

[1180] 2. Setting NPC basic characteristics

[1181] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[1182] Example: A user sets "Personality: Brave", "Skill: Swordsmanship", and "Reaction Speed: Fast".

[1183] 3. Sending the setting data

[1184] The terminal sends configuration data to the server, which includes the basic characteristics of the NPCs that the user has configured.

[1185] 4. Generation of initial behavioral patterns

[1186] The server uses an AI model to generate initial behavioral patterns based on the received basic characteristic data.

[1187] Example: The server generates behavioral patterns such as "attack immediately when you find an enemy" or "support when you find an ally."

[1188] 5. Presenting and confirming behavioral patterns

[1189] The generated behavioral patterns are displayed on the terminal and the user is asked to confirm them. The user can then confirm the behavioral patterns and request corrections if necessary.

[1190] 6. Running the Simulation

[1191] The server simulates the behavior patterns in a virtual environment, where you can see how the NPCs actually perform the behaviors you set.

[1192] Example: In a virtual environment, a scene is recreated in which an NPC "attacks immediately when it finds an enemy."

[1193] 7. Analysis of Simulation Results

[1194] The server analyzes the results of the simulation and identifies unnatural behavior and areas for improvement.

[1195] Example: A server detects issues such as "slow response times."

[1196] 8. Sending and Viewing Reports

[1197] The server sends the analysis results to the terminal as a report, and the user can use this report to check for changes to the NPC's behavior patterns.

[1198] 9. Modifying Behavioral Patterns

[1199] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[1200] Example: A user makes a modification such as "speed up reaction time."

[1201] 10. Sending corrected data and regenerating behavioral patterns

[1202] Upon receiving the modified data sent from the terminal, the server regenerates a new behavioral pattern.

[1203] 11. Presentation and approval of the final behavioral model

[1204] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[1205] 12. Implementation of the Final Behavioral Model

[1206] The server uploads the approved final behavior model to the game server and completes the implementation.

[1207] Example: The final model is applied to the game server, and a realistic swordsman NPC appears in the game.

[1208] 13. Sending and Displaying Implementation Completion Notification

[1209] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[1210] Examples of concrete examples and prompts

[1211] Example: A brave swordsman NPC created by the user realistically recreates situations in the actual game where he or she fights enemies or supports allies.

[1212] Example of a prompt: Input to the generation AI model, "Generate the behavior pattern of a brave swordsman. Example: Attack immediately when you find an enemy, and support when you find an ally."

[1213] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, which is expected to significantly improve the quality and efficiency of game development.

[1214] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1215] Step 1:

[1216] The user logs in to the Real NPC Development Tool using a terminal. The user enters their ID and password to access the system. If login is successful, the main menu will be displayed.

[1217] Input: ID and password

[1218] Output: Display main menu

[1219] Specific operation: The user enters their ID and password and clicks the "Login" button.

[1220] Step 2:

[1221] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[1222] Input: Basic characteristics such as personality, skills, and reaction speed

[1223] Output: Basic characteristic data

[1224] Specific operation: The user sets basic characteristics for each field, such as "personality: brave," "skill: swordsmanship," and "reaction speed: fast."

[1225] Step 3:

[1226] The device sends configuration data to the server, which includes the basic characteristics of the NPCs configured by the user.

[1227] Input: Basic characteristic data

[1228] Output: Notify the server that data has been sent

[1229] Specific operation: The terminal clicks the "Send" button to send the user's input data to the server.

[1230] Step 4:

[1231] Based on the basic characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[1232] Input: Basic characteristic data

[1233] Output: Initial behavior pattern

[1234] Specific operation: The server inputs a prompt such as "Please generate the behavior pattern of a brave swordsman" into the generated AI model, and obtains behavior patterns such as "attack immediately when an enemy is found" and "support when an ally is found" from the model.

[1235] Step 5:

[1236] The generated behavioral patterns are sent to the terminal and the user is asked to confirm them. The user can then confirm the presented behavioral patterns and request corrections if necessary.

[1237] Input: Initial behavior pattern

[1238] Output: Present behavioral patterns to the user

[1239] Specific operation: The device displays the behavior pattern along with the message "Please check your behavior pattern."

[1240] Step 6:

[1241] The server simulates the behavior patterns in a virtual environment, and the simulation confirms how the NPCs would actually perform the set actions.

[1242] Input: Behavioral pattern

[1243] Output: Simulation results

[1244] Specific operation: The server starts the virtual environment and recreates a scene in which the NPC "attacks immediately when it finds an enemy."

[1245] Step 7:

[1246] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[1247] Input: Simulation results

[1248] Output: Analysis report

[1249] Specific operation: The server analyzes the simulation log and detects problems such as "slow response time."

[1250] Step 8:

[1251] The server sends the analysis results to the device as a report, and the user can use this report to determine how to modify the NPC's behavior patterns.

[1252] Input: Analysis Report

[1253] Output: Report sent to terminal

[1254] Specific operation: The server sends the generated report to the terminal and displays a notification to the user saying "Please check the report."

[1255] Step 9:

[1256] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[1257] Input: Correction property data

[1258] Output: Notification of completion of sending corrected characteristic data

[1259] Specific action: The user makes a correction, such as "speeding up the response time," and clicks the "Submit" button.

[1260] Step 10:

[1261] The terminal sends the modified data to the server, and the server recreates the new behavioral pattern.

[1262] Input: Correction property data

[1263] Output: Regenerated behavior pattern

[1264] Specific operation: The server inputs new data into the generative AI model to generate optimized behavioral patterns.

[1265] Step 11:

[1266] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[1267] Input: Final behavior pattern

[1268] Output: Request for approval from user

[1269] Specific behavior: The device will display a notification saying "Please confirm and approve the final behavior pattern."

[1270] Step 12:

[1271] The server uploads the approved final behavior model to the game server, completing the implementation.

[1272] Input: Final behavior model

[1273] Output: Implementation completion notification to the game server

[1274] Specific operation: The server transfers the final behavior model to the game server and completes the implementation process.

[1275] Step 13:

[1276] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[1277] Input: Implementation completion information

[1278] Output: Notification to the user that implementation is complete

[1279] Specific behavior: The device displays the message "Implementation completed" to the user.

[1280] (Application example 1)

[1281] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1282] Designing and optimizing the behavior patterns of current non-player characters (NPCs) and industrial robots requires a significant amount of time and effort. Furthermore, manual configuration and debugging are prone to human error, reducing overall efficiency. Furthermore, analyzing simulation results and reconfiguring them to appropriate behavior patterns requires specialized knowledge, resulting in a lack of versatility. These issues make it difficult to achieve natural and efficient behavior for NPCs and industrial robots.

[1283] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1284] In this invention, the server includes terminal means for a user to input basic characteristics of a non-player character or an industrial robot, server means for generating behavior patterns of the non-player character or the industrial robot based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, and means for implementing the optimized behavior patterns in a game server or an industrial system. This allows users to easily design, optimize, and implement behavior patterns of NPCs and industrial robots, enabling them to perform efficient and natural movements.

[1285] "Terminal means" refers to a device used by a user to make settings or input data, such as a smartphone, a personal computer, or a factory control terminal.

[1286] "Server means" refers to a computer system that runs on a cloud or local server and processes, simulates, analyzes, and optimizes data.

[1287] "Behavior pattern" refers to a set of rules or algorithms that define the movements or behavior of a non-player character or industrial robot.

[1288] "Simulation" refers to the process of recreating and testing the behavioral patterns of non-player characters or industrial robots within a virtual environment.

[1289] "Optimization" refers to the process of improving inefficient or unnatural behavior based on simulation results and generating more appropriate behavioral patterns.

[1290] A "game server" refers to a server that centrally manages in-game information and processing and processes data for players and NPCs.

[1291] "Industrial systems" refers to all systems used in factories for production lines, robot control, data management, etc.

[1292] "Non-player character (NPC)" refers to a character in a game that is not controlled by the player and behaves according to programmed actions.

[1293] An "industrial robot" refers to a mechanical device that can automatically perform tasks in the production process within a factory.

[1294] The system for carrying out the present invention comprises a user terminal means, a server means, a simulation means, an optimization means, and an implementation means. A specific embodiment of the system will be described below.

[1295] First, the user logs into the system using a dedicated device (e.g., smartphone, PC, factory control terminal). After logging in, the user clicks the "Set new movement pattern" button and inputs the basic characteristics of the target non-player character (NPC) or industrial robot (e.g., movement speed, priority of various tasks, etc.). This setting data is sent from the device to the server.

[1296] The server generates an initial behavioral pattern based on the received basic characteristics. This process uses machine learning frameworks such as TensorFlow and PyTorch. For example, an industrial robot's behavioral pattern might include the task of "picking up packages from a conveyor belt and placing them on a pallet." The server generates this behavior sequence and simulates it in a virtual environment.

[1297] Simulation is the process of testing how generated behavioral patterns perform within a virtual environment. Once the simulation is complete, the simulation results are sent to a server, which analyzes the results and identifies unnatural behaviors or lack of efficiency. This analysis is performed by machine learning algorithms.

[1298] Next, the server modifies and optimizes the movement pattern based on the analysis results. For example, modifications such as "reducing the time it takes to pick up luggage" or "optimizing the speed of movement" are made. The optimized movement pattern is saved again on the server and the user is asked to confirm it.

[1299] Once the user approves the optimized motion pattern, the implementation means uploads the final behavior model to the game server or industrial system, and the implementation is completed, allowing the non-player characters and industrial robots to behave efficiently and naturally.

[1300] This system allows users to easily design, optimize, and implement behavior patterns for NPCs and industrial robots. As a concrete example, the following prompt sentences can be used:

[1301] Example prompt sentence:

[1302] "Start a simulation for the configuration where you want to optimize the robot's motion pattern. The robot will pick items and place them on a pallet. You want to reduce the time from start to finish."

[1303] When this prompt is sent to the server, a machine learning algorithm identifies areas for improvement in behavior and generates optimized patterns.The hardware used includes user devices (smartphones, PCs, factory control terminals), servers (cloud or local servers), and industrial robots (ARM robots, etc.).The software used includes server-side scripts (Python or JavaScript), machine learning frameworks (TensorFlow, PyTorch), and front-end frameworks (React, Vue.js).

[1304] The implementation of this system is expected to significantly improve the efficiency of industrial production lines and the realism of in-game NPCs.

[1305] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1306] Step 1:

[1307] A user logs in to the system using a terminal.

[1308] (Input) User authentication information (user ID, password)

[1309] (Output) Login success message and system home screen

[1310] (Specific operation) The user enters login information into the device and clicks the "Login" button. The device sends the authentication information to the server, which verifies the authentication information and displays the home screen if successful.

[1311] Step 2:

[1312] The user sets a new behavior pattern using the terminal.

[1313] (Input) Basic characteristics of a non-player character or industrial robot (speed of movement, task priority, etc.)

[1314] (Output) Setting data (JSON format, etc.)

[1315] (Specific operation) The user enters the required characteristics on the device's setting screen and clicks the "Save settings" button. The device then sends the entered setting data to the server.

[1316] Step 3:

[1317] The server generates an initial behavior pattern based on the basic characteristics.

[1318] (Input) Setting data

[1319] (Output) Initial behavior pattern (algorithm or rule set)

[1320] (Specific Operation) The server receives the configuration data and generates an initial behavioral pattern using a generative AI model (using TensorFlow or PyTorch). This generated behavioral pattern is, for example, an action sequence of "picking up luggage and placing it on a pallet."

[1321] Step 4:

[1322] The server simulates the generated behavioral patterns in a virtual environment.

[1323] (Input) Initial behavior pattern

[1324] (Output) Simulation results (log files, performance data, etc.)

[1325] (Specific operation) The server creates a virtual environment and executes the initial behavior pattern. At this time, it simulates the robot's behavior in the virtual environment in real time and records the results.

[1326] Step 5:

[1327] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[1328] (Input) Simulation results

[1329] (Output) Analysis results (report and recommended fixes)

[1330] (Specific operation) The server analyzes the simulation log files and performance data, and uses machine learning algorithms to identify unnatural behavior and inefficiencies.

[1331] Step 6:

[1332] The user uses the terminal to check the analysis results and correct the behavioral patterns as necessary.

[1333] (Input) Analysis results, correction parameters

[1334] (Output) Modified behavior pattern

[1335] (Specific operation) The user checks the analysis results displayed on the terminal, and if any corrections are necessary, they input the parameters and reset them. The corrected data is sent back to the server.

[1336] Step 7:

[1337] The server regenerates and optimizes the behavioral patterns based on the modified parameters.

[1338] (Input) Modified parameters

[1339] (Output) Optimized behavioral patterns

[1340] (Specific Operation) The server receives the modified parameters and generates and optimizes the behavioral pattern again. In the optimization process, a simulation is performed again to generate the optimal pattern.

[1341] Step 8:

[1342] The user approves the optimized behavior pattern and the server implements it.

[1343] (Input) Optimized behavioral patterns, user approval

[1344] (Output) Implementation completion notification

[1345] (Specific operation) The user checks the optimized behavior pattern on the device and clicks the "Approve" button. The server uploads the approved behavior pattern to the game server or industrial system and sends a notification of implementation completion to the device.

[1346] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1347] This invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. Furthermore, by combining this system with an emotion engine that recognizes the user's emotions and adjusts the NPC's behavior patterns based on those emotions, it provides a more realistic interactive experience.

[1348] First, the user uses the terminal to log in to the game development tool. After logging in, the user clicks the "Create a new NPC" button and sets the basic characteristics of the NPC. For example, the following characteristics can be set:

[1349] Personality: Brave

[1350] Skill: Swordsman

[1351] Reaction speed: Fast

[1352] Once the user sets these basic characteristics, the information is sent from the device to the server. The server uses this data to generate initial behavioral patterns using an AI algorithm. Behavioral scenarios based on the basic characteristics include "attack immediately when an enemy is found" and "support when an ally is found."

[1353] The generated behavioral patterns are then sent to the device and displayed to the user. After the user confirms the behavioral patterns, the server creates a virtual environment and starts the simulation. A specific simulation example is a scene where an NPC encounters an enemy in a virtual combat scenario. Once the simulation is complete, the server analyzes the results, identifies unnatural behaviors and areas for improvement, and generates a report. This report is sent to the device and displayed to the user.

[1354] Based on the report, users can modify the NPC's behavior patterns. For example, they can adjust the settings to speed up the "reaction time to finding an enemy." This modified data is sent back to the server, which then regenerates and optimizes the behavior patterns based on the new settings. After the final behavior model is generated, it is sent back to the device for user approval.

[1355] On the other hand, by using an emotion engine, it is possible to adjust behavioral patterns according to the user's emotional state. Specifically, the emotion engine installed on the device recognizes emotions from the user's facial recognition data and voice tone, and sends this data to the server. The server analyzes the received emotion recognition data and dynamically adjusts behavioral patterns, such as making NPCs more cooperative if the user is feeling stressed.

[1356] As a result, NPCs can better respond to user interactions, improving the game's realism and appeal. For example, if the user is nervous, the NPCs will act more cautiously, and if the user is relaxed, the NPCs will act more boldly.

[1357] Once the final behavioral model is approved by the user, the server uploads it to the game server and completes the implementation. Once the implementation is complete, the results are notified to the device so that the user can check them.

[1358] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic in-game experience, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[1359] The processing flow will be explained below.

[1360] Step 1:

[1361] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[1362] Step 2:

[1363] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[1364] Step 3:

[1365] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[1366] Step 4:

[1367] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[1368] Step 5:

[1369] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[1370] Step 6:

[1371] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[1372] Step 7:

[1373] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[1374] Step 8:

[1375] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[1376] Step 9:

[1377] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[1378] Step 10:

[1379] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[1380] Step 11:

[1381] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[1382] Step 12:

[1383] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[1384] Step 13:

[1385] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[1386] Step 14:

[1387] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[1388] Step 15:

[1389] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[1390] Step 16:

[1391] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[1392] Step 17:

[1393] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[1394] Step 18:

[1395] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[1396] Step 19:

[1397] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[1398] Step 20:

[1399] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[1400] Step 21:

[1401] Emotion Engine: Analyzes the user's face and voice to recognize emotions, determining the user's emotional state in real time.

[1402] Step 22:

[1403] Emotion engine: Sends emotion data to the server. Enables the server to receive emotion data.

[1404] Step 23:

[1405] Server: Dynamically adjusts behavior patterns based on emotion data. Changes NPC behavior according to the user's emotions.

[1406] Step 24:

[1407] Server: Generates the final adjusted behavioral model and sends it to the device. Sends the data so that the user can check it.

[1408] Step 25:

[1409] Terminal: Displays the adjusted behavioral model to the user and asks for approval. Provides an interface for the user to confirm the adjustments.

[1410] Step 26:

[1411] User: Approves the final adjusted behavioral model. Finally, confirms the behavioral model according to the emotion.

[1412] Step 27:

[1413] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[1414] Step 28:

[1415] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[1416] Step 29:

[1417] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[1418] Step 30:

[1419] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[1420] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and emotions, and then implement them in the game.

[1421] Example 2

[1422] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1423] In conventional game systems, the process of generating and optimizing the behavior patterns of non-player characters (NPCs) is often done manually, placing a heavy burden on developers. Furthermore, it is difficult to dynamically adjust NPC behavior based on user emotions, limiting the interactive experience. It is necessary to solve these problems and improve development efficiency and the quality of the game experience.

[1424] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1425] In this invention, the server includes user interface means for allowing a user to input basic characteristics of non-player characters, data processing means for generating behavioral patterns of non-player characters based on the input basic characteristics, data processing means for simulating the generated behavioral patterns, data processing means for analyzing the simulation results and generating optimized behavioral patterns, communication means for implementing the optimized behavioral patterns, and emotion analysis means for recognizing user emotions and dynamically adjusting the behavioral patterns of non-player characters based on that data. This enables dynamic behavior adjustment in response to user emotions, making it possible to provide a realistic and engaging interactive experience while reducing the burden on developers.

[1426] "User interface means" refers to an input device and a display device that allow a user to input basic characteristics and modification parameters of a non-player character.

[1427] "Data processing means" refers to a device that executes algorithms or programs to generate, simulate, analyze and optimize behavioral patterns based on received data.

[1428] "Communication means" refers to the network interface and protocol for uploading and implementing optimized behavioral patterns to the game server.

[1429] "Emotion analysis means" refers to software and hardware for recognizing emotions from a user's facial recognition data and voice tone and analyzing that data.

[1430] "Virtual environment" refers to a simulated environment constructed to test and evaluate the behavioral patterns of non-player characters.

[1431] "Non-player characters" refer to characters that appear in the game and act separately from the user.

[1432] A "behavior pattern" refers to a series of actions or reactions that a non-player character performs in a particular situation.

[1433] "Simulation" refers to the process of replicating the behavioral patterns of non-player characters within a virtual environment and evaluating their actions.

[1434] "Basic characteristics" refers to the initial attributes of a non-player character, such as personality, skills, reaction speed, etc.

[1435] "Parameters" refer to numerical values ​​and settings used to control and adjust the behavior patterns of non-player characters.

[1436] This invention is a system that automatically generates behavior patterns for non-player characters (NPCs) and implements them in a game through simulation and optimization. Furthermore, it combines an emotion engine that recognizes user emotions and dynamically adjusts NPC behavior patterns based on those emotions to provide a more realistic interactive experience. The following describes in detail the embodiments of this invention.

[1437] Hardware and software used

[1438] Hardware:

[1439] Terminal (including user interface means)

[1440] Server (including data processing means and communication means)

[1441] Camera and microphone for emotion analysis (including emotion analysis means)

[1442] software:

[1443] Game Development Tools

[1444] AI algorithms (used for generating and optimizing behavioral patterns)

[1445] Emotion engine (analyzes user emotions)

[1446] Simulation environment construction software

[1447] Specific processing explanation of the system

[1448] User Action:

[1449] First, the user logs in to the game development tool using a terminal. After successfully logging in, the main screen appears and the user clicks the "Create a new NPC" button. The user enters the NPC's basic characteristics (e.g., personality, skills, reaction speed) in the displayed form and clicks the "Submit" button.

[1450] Data transmission and processing:

[1451] The device sends the set characteristic data to the server, which then runs an AI algorithm based on the received characteristic data to generate the NPC's initial behavior pattern. The generated behavior pattern is then sent back to the device and displayed to the user.

[1452] Simulation and optimization:

[1453] The server creates a virtual environment and simulates the generated behavior patterns, such as an NPC encountering an enemy in a virtual combat scenario. The simulation results are analyzed by the server to identify unnatural behaviors and areas for improvement, and a report is generated. This report is sent to the device and displayed to the user.

[1454] Behavioral pattern modification and regeneration:

[1455] The user can then modify the NPC's behavior based on the report and send the modified data back to the server. The server then re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing the behavior. Once the final behavior model is generated, it is sent back to the device for user approval.

[1456] Dynamic adjustment with emotion engine:

[1457] The device runs an emotion engine that analyzes the user's emotions based on facial recognition data, voice tone, etc. The analyzed emotion data is sent to a server, which then dynamically adjusts the NPC's behavior patterns based on the user's emotional state. For example, if the user is stressed, the NPC will behave more cooperatively, and if the user is relaxed, the NPC will behave more boldly.

[1458] Example prompt sentence:

[1459] Generate a new NPC's behavioral pattern. Consider the following characteristics:

[1460] Personality: Brave

[1461] Skill: Swordsman

[1462] Reaction speed: Fast

[1463] Examples of behavioral patterns include 'attack immediately when you spot an enemy' and 'support when you spot an ally.'

[1464] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic interactive experience in the game, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[1465] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1466] Program processing flow

[1467] Step 1: User logs into game development tools

[1468] The user opens the login screen of the game development tool using the terminal, enters the username and password, and clicks the "Login" button.

[1469] Input: Username, Password

[1470] Output: Game development tool main screen

[1471] Operation: If the username and password are successfully authenticated, the main screen will be displayed.

[1472] Step 2: User initiates creation of a new NPC

[1473] The user clicks the "Create a new NPC" button on the main screen.

[1474] Input: "Create New NPC" button click event

[1475] Output: NPC basic characteristics input form

[1476] Effect: A form will appear where you can enter the NPC's basic characteristics.

[1477] Step 3: The device sends the NPC's characteristic data to the server.

[1478] The user inputs the basic characteristics of the NPC (e.g., personality, skills, reaction speed) and clicks the "Send" button. The device then sends this data to the server.

[1479] Input: NPC base characteristic data

[1480] Output: Attribute data sent to the server

[1481] Operation: The device sends the entered characteristic data to the server's API.

[1482] Step 4: The server generates the initial behavior patterns of the NPC.

[1483] Based on the characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[1484] Input: NPC base characteristic data

[1485] Output: Initial behavior pattern

[1486] Behavior: AI algorithms analyze characteristic data and generate behavioral patterns.

[1487] Step 5: The server sends the initial behavior pattern to the terminal and displays it to the user.

[1488] The server transmits the generated behavior pattern to the terminal, and the user confirms the behavior pattern.

[1489] Input: Initial behavior pattern

[1490] Output: Behavioral patterns displayed on the terminal

[1491] Operation: The server sends the behavioral patterns to the device and updates the UI for display.

[1492] Step 6: The server starts the simulation

[1493] After the user confirms their behavioral patterns, the server creates a virtual environment and starts the simulation, for example, simulating an NPC encountering an enemy in a virtual combat scenario.

[1494] Input: Action pattern approval instructions

[1495] Output: Simulation results

[1496] Operation: The server creates a virtual environment and executes a behavioral pattern scenario.

[1497] Step 7: The server analyzes the simulation results and generates a report

[1498] After the simulation is complete, the server analyzes the results, identifies any unusual behaviors and areas for improvement, and generates a report.

[1499] Input: Simulation result data

[1500] Output: Analysis results and reports

[1501] How it works: The server analyzes the resulting data and generates a report.

[1502] Step 8: The server sends the report to the terminal and displays it to the user.

[1503] The server sends the report to the terminal, and the user checks the contents of the report.

[1504] Input: Generated report

[1505] Output: Report displayed on terminal

[1506] What it does: The server sends the report data to the device and updates the UI for display.

[1507] Step 9: User modifies NPC behavior patterns

[1508] The user inputs the parameters of the behavioral pattern that he / she wants to modify based on the report and clicks the "Update" button.

[1509] Input: Correction parameters

[1510] Output: Correction data sent from the device to the server

[1511] Operation: The device sends the modification parameters to the server's API.

[1512] Step 10: The device sends the correction data to the server

[1513] The modified data is transmitted from the terminal to the server and received by the server.

[1514] Input: Correction parameter data

[1515] Output: Modified data stored on the server

[1516] How it works: The device sends correction data via API to the server, which receives and stores the data.

[1517] Step 11: The server recreates and optimizes the behavioral patterns

[1518] The server re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing new behavioral patterns.

[1519] Input: Correction parameter data

[1520] Output: Optimized behavioral patterns

[1521] How it works: The server re-runs the AI ​​algorithms to regenerate and optimize behavioral patterns.

[1522] Step 12: The server sends the final behavior model to the terminal and asks for user approval.

[1523] Once the final behavioral model is generated, the server sends the data to the terminal and asks for the user's approval.

[1524] Input: Optimized behavioral patterns

[1525] Output: Final behavioral model displayed on the terminal

[1526] Operation: The server sends the final behavior model to the device and updates the UI for display.

[1527] Step 13: The device runs the emotion engine and recognizes the user's emotion.

[1528] The emotion engine installed in the device analyzes the user's facial recognition data and voice tone to recognize the user's emotions.

[1529] Input: User's facial recognition data, audio tone

[1530] Output: Sentiment analysis data

[1531] How it works: The device's emotion engine analyzes the input data and identifies the user's emotion.

[1532] Step 14: The server dynamically adjusts behavioral patterns based on emotion data.

[1533] Based on the received emotional data, the server dynamically adjusts the NPC's behavior patterns according to the user's emotional state.

[1534] Input: Sentiment analysis data

[1535] Output: Dynamically adjusted behavioral patterns

[1536] How it works: The server analyzes the sentiment analysis data and adjusts behavioral patterns.

[1537] Step 15: The server uploads the final behavior model to the game server.

[1538] The final behavior model approved by the user is uploaded from the server to the game server.

[1539] Input: Approved Final Behavioral Model

[1540] Output: Behavioral model implemented on the game server

[1541] Operation: The server uploads the behavior model to the game server and completes the implementation.

[1542] Step 16: The device displays a notification to the user that the implementation is complete.

[1543] Once the implementation is complete, the results are notified to the terminal and can be confirmed by the user.

[1544] Input: Implementation Completion Notification

[1545] Output: A completion notification displayed on the terminal

[1546] Action: The device receives a notification that the implementation is complete and displays it to the user.

[1547] (Application example 2)

[1548] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1549] Conventional food delivery services have struggled to provide an experience that takes into account the emotions of customers during delivery. Furthermore, delivery by general autonomous robots lacks the ability to respond appropriately to situations where the customer is tired or relaxed, making it difficult to improve customer satisfaction.

[1550] The identification processing by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, means for implementing the optimized behavior patterns on the game server, server means for recognizing the user's emotions and dynamically adjusting the behavior patterns of non-player characters in accordance with the emotions, and terminal means for recognizing the user's emotions in the autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions. This enables the autonomous delivery robot to respond in accordance with the emotions of customers, providing customers with a personalized delivery experience.

[1551] "Terminal means for the user to input the basic characteristics of a non-player character" refers to a device that allows the user to set the characteristics of a non-player character (NPC), and by which the user can input characteristics such as the personality and skills of the NPC.

[1552] The "server means for generating behavior patterns of non-player characters based on input basic characteristics" is a server for generating behavior patterns of NPCs using an algorithm based on the characteristic information of the NPCs input by the user.

[1553] The "server means for simulating the generated behavior pattern" is a server for running the generated behavior pattern of the NPC on a trial basis in a virtual environment and simulating it.

[1554] The "server means for analyzing the simulation results and generating optimized behavioral patterns" is a server for evaluating and analyzing the simulation results, correcting unnatural or inefficient behaviors, and generating optimized behavioral patterns.

[1555] "Means for implementing optimized behavior patterns on a game server" refers to means for applying optimized NPC behavior patterns within a game and making them operate in an actual game environment.

[1556] "Server means for recognizing the user's emotions and dynamically adjusting the behavioral patterns of non-player characters in accordance with those emotions" refers to a server that analyzes the user's emotional state (for example, through facial recognition or voice recognition) and adjusts the behavior of NPCs in real time based on the results.

[1557] "Terminal means for recognizing the emotions of a user in an autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions" refers to a terminal that allows an autonomous food delivery robot to analyze the emotions of a customer when making a delivery and adjust the robot's behavior and greeting message according to those emotions.

[1558] This invention is a system for food delivery services in which an autonomous delivery robot recognizes the emotions of customers and dynamically adjusts its behavior in response to those emotions. This system includes a terminal means for users to set the behavior patterns of non-player characters (NPCs), a server means for performing simulations and optimization based on those behavior patterns, and a function for recognizing customer emotions and adjusting the behavior of the delivery robot.

[1559] System Configuration

[1560] 1. Terminal means

[1561] The user inputs basic characteristics of the NPC using the terminal means, such as personality, skills, reaction speed, etc.

[1562] 2. Server Means

[1563] The server means generates behavior patterns of the NPC based on the basic characteristics input by the user. The generated behavior patterns are then simulated and the simulation results are analyzed. The server optimizes the behavior patterns of the NPC based on the simulation results. The optimized behavior patterns are finally implemented on the game server.

[1564] 3. Emotion recognition and behavioral regulation

[1565] The server also has the ability to recognize the user's emotions. This is done using facial expression analysis and voice tone analysis. This allows the server to understand the user's state, such as whether they are tired or relaxed. The server dynamically adjusts the behavior of NPCs based on the recognized emotions.

[1566] 4. Delivery robots

[1567] A food delivery robot receives instructions from the server and adjusts its behavior according to the customer's emotions. For example, if the robot detects that the customer is tired, it will deliver quickly and quietly and play a message like, "Thank you for your hard work. Here's your delivery. Please relax." On the other hand, if the customer is relaxed, the robot will deliver at a normal speed and play a message like, "Thank you for your order! We'll deliver it to you soon!"

[1568] Hardware and software used

[1569] Devices: personal computers and smartphones

[1570] Server: High-performance cloud server

[1571] Emotion recognition: facial recognition software (e.g., Emotion API), voice recognition software

[1572] Delivery Robot: Autonomous robot for food delivery

[1573] Generative AI model: Behavioral pattern generation system

[1574] Specific examples

[1575] Scenario 1: A customer receives a delivery after a long day. Emotion recognition software recognizes the customer's facial expression as "tired." The delivery robot plays a message saying, "Thank you for your hard work. Here's your delivery. Please relax." and quietly makes the delivery.

[1576] Scenario 2: A customer is having a good time with friends. The emotion recognition software recognizes the customer's facial expression as "happy." The delivery robot plays a message saying, "Thank you for your order! We'll deliver it to you soon!" and delivers the package at a normal speed.

[1577] Prompt Sentence Examples

[1578] "If the customer's emotion is 'tired,' the robot will deliver quickly and quietly, playing the message, 'Thank you for your hard work. Here's your delivery. Please relax.' If the customer's emotion is 'happy,' the robot will deliver at a normal speed, playing the message, 'Thank you for your order! We'll deliver it to you soon!'"

[1579] The present invention enables the food delivery experience to be highly personalized according to the customer's emotional state, which is expected to improve customer satisfaction.

[1580] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1581] Step 1:

[1582] The terminal allows the user to input the basic characteristics of the non-player character. At this time, the user sets characteristics such as personality, skills, and reaction speed. The terminal receives the input basic characteristics and transmits them to the server. The input data includes "brave," "swordsman," and "fast."

[1583] Step 2:

[1584] The server receives the basic characteristics sent from the device and generates initial behavior patterns for non-player characters based on that information. The server analyzes the input data and generates behavior patterns using an algorithm. The generated behavior patterns include "attack immediately when an enemy is found" and "support when an ally is found."

[1585] Step 3:

[1586] The server constructs a virtual environment to simulate the generated behavioral patterns and starts the simulation. It experimentally reproduces the behavior of non-player characters in the virtual environment and collects the results. The output of the simulation is data including, for example, "attacking an enemy in a battle scenario" and "supporting an ally."

[1587] Step 4:

[1588] The server analyzes the simulation results and identifies unnatural behaviors and areas for improvement. It then organizes the simulation data and generates optimized behavior patterns. For example, this includes adjusting reaction speed and modifying attack patterns to make them more effective. The optimized data is the optimized behavior pattern.

[1589] Step 5:

[1590] The server implements the optimized behavior pattern on the game server. After implementation, these settings are reflected in the game, and the non-player characters behave in the actual game environment. The game server then verifies that the behavior pattern has been applied correctly and notifies the terminal of the result. The output is a notification that "The behavior pattern has been implemented."

[1591] Step 6:

[1592] The device collects data through a camera and microphone to recognize the user's emotions. The collected data is sent to an emotion recognition engine that analyzes the user's facial expressions and voice tone. The input data is video and audio data.

[1593] Step 7:

[1594] The server analyzes the collected facial expression and voice tone data to identify the user's emotional state. For example, emotion recognition software is used to distinguish emotions such as "tired" or "happy." The analysis results in the recognition data such as "The user is tired."

[1595] Step 8:

[1596] The server dynamically adjusts the behavioral patterns of non-player characters based on the recognized emotional state. For example, if the user is tired, it sets the character's behavior to be more cooperative. The output is a message saying "Behavior pattern adjusted."

[1597] Step 9:

[1598] The terminal acquires the camera feed of the autonomous delivery robot and collects data that the robot can use to recognize customer emotions. The collected data is video data.

[1599] Step 10:

[1600] The server analyzes the customer's emotions based on the video data sent from the device. For example, it uses emotion recognition software to distinguish between "tired" and "happy." The analysis result is "The customer is feeling tired."

[1601] Step 11:

[1602] The server adjusts the behavior of the delivery robot based on the analysis results. For example, if the customer is tired, the delivery robot will deliver quickly and quietly and play a message saying, "Thank you for your hard work. Here's your delivery. Please relax." The output is a message saying, "Behavior adjusted."

[1603] This will enable autonomous food delivery robots to respond to customers' emotions, providing a more personalized experience.

[1604] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1605] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1606] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1607] [Fourth embodiment]

[1608] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1609] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[1610] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1611] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1612] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[1613] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[1614] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1615] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1616] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1617] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1618] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1619] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1620] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1621] The present invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and then implementing them in a game. Specific embodiments of this system are described below.

[1622] When a user creates an NPC, they first log in to the Real NPC Development Tool using their device. After logging in, the user clicks the "Create a New NPC" button and sets the basic characteristics (e.g., personality, skills, reaction speed). This setting data is sent from the device to the server.

[1623] The server generates an initial behavior pattern based on the received basic characteristics. For example, when creating a brave swordsman NPC, the server assumes actions such as "attack immediately when it finds an enemy" and "support when it finds an ally." The generated behavior pattern is then presented to the user via their device for confirmation.

[1624] Once the user confirms the proposed behavioral patterns, the server then starts the simulation. In this step, a virtual environment is created and how the NPC will behave in the game is tested. For example, a scene in which an NPC "attacks an enemy as soon as it finds one" is recreated in the simulated environment. After the simulation is run, the server analyzes the results and identifies unnatural behaviors and areas for improvement. The analysis results are sent to the device as a report and displayed to the user.

[1625] The user modifies the NPC's behavioral patterns based on the report. For example, they adjust the settings to speed up the "reaction time to finding an enemy." The modified settings are then sent back to the server from the device. The server regenerates and optimizes the behavioral patterns based on the new settings. Once the final behavioral model is generated, it is sent back to the device for user approval.

[1626] Finally, the behavior model approved by the user is uploaded to the game server by the server, and implementation is completed. Once implementation is complete, a completion notification is sent from the server to the device, and a notification of implementation completion is displayed to the user.

[1627] This system allows NPCs to behave more realistically, increasing player interaction and making games more engaging. It also improves game development efficiency by allowing developers to efficiently adjust NPC behavior patterns. For example, a brave swordsman NPC created by a user can realistically battle enemies or support allies in the actual game.

[1628] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, significantly improving the quality and efficiency of game development.

[1629] The processing flow will be explained below.

[1630] Step 1:

[1631] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[1632] Step 2:

[1633] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[1634] Step 3:

[1635] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[1636] Step 4:

[1637] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[1638] Step 5:

[1639] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[1640] Step 6:

[1641] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[1642] Step 7:

[1643] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[1644] Step 8:

[1645] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[1646] Step 9:

[1647] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[1648] Step 10:

[1649] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[1650] Step 11:

[1651] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[1652] Step 12:

[1653] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[1654] Step 13:

[1655] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[1656] Step 14:

[1657] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[1658] Step 15:

[1659] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[1660] Step 16:

[1661] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[1662] Step 17:

[1663] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[1664] Step 18:

[1665] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[1666] Step 19:

[1667] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[1668] Step 20:

[1669] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[1670] Step 21:

[1671] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[1672] Step 22:

[1673] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[1674] Step 23:

[1675] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[1676] Step 24:

[1677] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[1678] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and then implement them in the game.

[1679] Example 1

[1680] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1681] In conventional game development, the process of creating, simulating, and optimizing behavior patterns for non-player characters (NPCs) is extremely time-consuming and labor-intensive. In particular, it is difficult to detect unnatural behavior and make appropriate corrections based on that information, resulting in a decline in the overall quality of the game. The present invention aims to solve these problems and provide an efficient system for making NPCs behave more realistically.

[1682] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1683] In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, means for identifying unnatural movements and areas for improvement based on the simulation results and sending the results to the user as a report, means for generating a final behavior model based on the user's approval and implementing it on the game server, and means for sending an implementation completion notification to the user. This makes it possible to efficiently generate, simulate, and optimize NPC behavior patterns and immediately implement them in the game.

[1684] A "user" is a user who operates this system and sets the basic characteristics and behavior patterns of non-player characters.

[1685] A "non-player character (NPC)" is a character that is not a player in a game and whose actions are controlled by a program.

[1686] "Basic characteristics" are basic attributes that determine the behavior of a character, such as the personality, skills, and reaction speed of a non-player character.

[1687] "Terminal means" refers to a device that a user uses to modify the settings and behavior patterns of non-player characters, and includes a personal computer, tablet, smartphone, etc.

[1688] "Server means" is a central processing unit for generating, simulating, analyzing, and optimizing behavior patterns of non-player characters.

[1689] A "virtual environment" is a simulated real-world environment created for the purpose of testing and simulating the behavioral patterns of non-player characters.

[1690] A "behavior pattern" is a set of actions and reactions that determine how a non-player character will behave in a particular situation.

[1691] "Simulation" is the process of testing how the behavioral patterns of non-player characters will function within a virtual environment.

[1692] The "report" is a report summarizing the results of analyzing the simulation results and identifying unnatural behaviors and areas for improvement.

[1693] A "final behavior model" is a behavior pattern of a non-player character that has been optimized after receiving user approval and is implemented on the game server.

[1694] A "game server" is a server that executes the actions of non-player characters in a game using a final behavior model.

[1695] The "implementation completion notification" is a notification to inform the user that the final behavior model has been correctly applied to the game server.

[1696] This invention relates to a system for automatically generating behavioral patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. This system streamlines the process for users to create and optimize NPCs, enabling more realistic NPC behavior in games.

[1697] Hardware and software used

[1698] Hardware:

[1699] User devices: PCs, tablets, smartphones, etc.

[1700] Server: Server equipment as a central processing unit

[1701] software:

[1702] Real NPC Development Tool: Software for setting and modifying basic characteristics of NPCs

[1703] Simulation engine: Software for simulating NPC behavior patterns in a virtual environment

[1704] Game Server: Software for implementing the final behavior model in the game

[1705] Data processing and calculation details

[1706] 1. User logs in

[1707] The user logs in to the Real NPC Development Tool using a terminal. After entering their ID and password and successfully logging in, the main menu is displayed.

[1708] 2. Setting NPC basic characteristics

[1709] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[1710] Example: A user sets "Personality: Brave", "Skill: Swordsmanship", and "Reaction Speed: Fast".

[1711] 3. Sending the setting data

[1712] The terminal sends configuration data to the server, which includes the basic characteristics of the NPCs that the user has configured.

[1713] 4. Generation of initial behavioral patterns

[1714] The server uses an AI model to generate initial behavioral patterns based on the received basic characteristic data.

[1715] Example: The server generates behavioral patterns such as "attack immediately when you find an enemy" or "support when you find an ally."

[1716] 5. Presenting and confirming behavioral patterns

[1717] The generated behavioral patterns are displayed on the terminal and the user is asked to confirm them. The user can then confirm the behavioral patterns and request corrections if necessary.

[1718] 6. Running the Simulation

[1719] The server simulates the behavior patterns in a virtual environment, where you can see how the NPCs actually perform the behaviors you set.

[1720] Example: In a virtual environment, a scene is recreated in which an NPC "attacks immediately when it finds an enemy."

[1721] 7. Analysis of Simulation Results

[1722] The server analyzes the results of the simulation and identifies unnatural behavior and areas for improvement.

[1723] Example: A server detects issues such as "slow response times."

[1724] 8. Sending and Viewing Reports

[1725] The server sends the analysis results to the terminal as a report, and the user can use this report to check for changes to the NPC's behavior patterns.

[1726] 9. Modifying Behavioral Patterns

[1727] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[1728] Example: A user makes a modification such as "speed up reaction time."

[1729] 10. Sending corrected data and regenerating behavioral patterns

[1730] Upon receiving the modified data sent from the terminal, the server regenerates a new behavioral pattern.

[1731] 11. Presentation and approval of the final behavioral model

[1732] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[1733] 12. Implementation of the Final Behavioral Model

[1734] The server uploads the approved final behavior model to the game server and completes the implementation.

[1735] Example: The final model is applied to the game server, and a realistic swordsman NPC appears in the game.

[1736] 13. Sending and Displaying Implementation Completion Notification

[1737] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[1738] Examples of concrete examples and prompts

[1739] Example: A brave swordsman NPC created by the user realistically recreates situations in the actual game where he or she fights enemies or supports allies.

[1740] Example of a prompt: Input to the generation AI model, "Generate the behavior pattern of a brave swordsman. Example: Attack immediately when you find an enemy, and support when you find an ally."

[1741] As described above, the system of the present invention can efficiently generate, simulate, and optimize NPC behavior models and instantly implement them in games, which is expected to significantly improve the quality and efficiency of game development.

[1742] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1743] Step 1:

[1744] The user logs in to the Real NPC Development Tool using a terminal. The user enters their ID and password to access the system. If login is successful, the main menu will be displayed.

[1745] Input: ID and password

[1746] Output: Display main menu

[1747] Specific operation: The user enters their ID and password and clicks the "Login" button.

[1748] Step 2:

[1749] The user clicks the "Create a new NPC" button and enters basic characteristics such as personality, skills, and reaction speed on the new NPC creation screen.

[1750] Input: Basic characteristics such as personality, skills, and reaction speed

[1751] Output: Basic characteristic data

[1752] Specific operation: The user sets basic characteristics for each field, such as "personality: brave," "skill: swordsmanship," and "reaction speed: fast."

[1753] Step 3:

[1754] The device sends configuration data to the server, which includes the basic characteristics of the NPCs configured by the user.

[1755] Input: Basic characteristic data

[1756] Output: Notify the server that data has been sent

[1757] Specific operation: The terminal clicks the "Send" button to send the user's input data to the server.

[1758] Step 4:

[1759] Based on the basic characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[1760] Input: Basic characteristic data

[1761] Output: Initial behavior pattern

[1762] Specific operation: The server inputs a prompt such as "Please generate the behavior pattern of a brave swordsman" into the generated AI model, and obtains behavior patterns such as "attack immediately when an enemy is found" and "support when an ally is found" from the model.

[1763] Step 5:

[1764] The generated behavioral patterns are sent to the terminal and the user is asked to confirm them. The user can then confirm the presented behavioral patterns and request corrections if necessary.

[1765] Input: Initial behavior pattern

[1766] Output: Present behavioral patterns to the user

[1767] Specific operation: The device displays the behavior pattern along with the message "Please check your behavior pattern."

[1768] Step 6:

[1769] The server simulates the behavior patterns in a virtual environment, and the simulation confirms how the NPCs would actually perform the set actions.

[1770] Input: Behavioral pattern

[1771] Output: Simulation results

[1772] Specific operation: The server starts the virtual environment and recreates a scene in which the NPC "attacks immediately when it finds an enemy."

[1773] Step 7:

[1774] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[1775] Input: Simulation results

[1776] Output: Analysis report

[1777] Specific operation: The server analyzes the simulation log and detects problems such as "slow response time."

[1778] Step 8:

[1779] The server sends the analysis results to the device as a report, and the user can use this report to determine how to modify the NPC's behavior patterns.

[1780] Input: Analysis Report

[1781] Output: Report sent to terminal

[1782] Specific operation: The server sends the generated report to the terminal and displays a notification to the user saying "Please check the report."

[1783] Step 9:

[1784] The user can then modify the NPC's behavior patterns based on the report, inputting the modifications into the terminal and sending them back to the server.

[1785] Input: Correction property data

[1786] Output: Notification of completion of sending corrected characteristic data

[1787] Specific action: The user makes a correction, such as "speeding up the response time," and clicks the "Submit" button.

[1788] Step 10:

[1789] The terminal sends the modified data to the server, and the server recreates the new behavioral pattern.

[1790] Input: Correction property data

[1791] Output: Regenerated behavior pattern

[1792] Specific operation: The server inputs new data into the generative AI model to generate optimized behavioral patterns.

[1793] Step 11:

[1794] The server sends the new behavioral pattern to the terminal and asks for the user's approval. If the user approves, the final behavioral model is established.

[1795] Input: Final behavior pattern

[1796] Output: Request for approval from user

[1797] Specific behavior: The device will display a notification saying "Please confirm and approve the final behavior pattern."

[1798] Step 12:

[1799] The server uploads the approved final behavior model to the game server, completing the implementation.

[1800] Input: Final behavior model

[1801] Output: Implementation completion notification to the game server

[1802] Specific operation: The server transfers the final behavior model to the game server and completes the implementation process.

[1803] Step 13:

[1804] The server sends a notification of completion of the implementation to the terminal, and a message of completion of the implementation is displayed to the user.

[1805] Input: Implementation completion information

[1806] Output: Notification to the user that implementation is complete

[1807] Specific behavior: The device displays the message "Implementation completed" to the user.

[1808] (Application example 1)

[1809] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1810] Designing and optimizing the behavior patterns of current non-player characters (NPCs) and industrial robots requires a significant amount of time and effort. Furthermore, manual configuration and debugging are prone to human error, reducing overall efficiency. Furthermore, analyzing simulation results and reconfiguring them to appropriate behavior patterns requires specialized knowledge, resulting in a lack of versatility. These issues make it difficult to achieve natural and efficient behavior for NPCs and industrial robots.

[1811] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1812] In this invention, the server includes terminal means for a user to input basic characteristics of a non-player character or an industrial robot, server means for generating behavior patterns of the non-player character or the industrial robot based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, and means for implementing the optimized behavior patterns in a game server or an industrial system. This allows users to easily design, optimize, and implement behavior patterns of NPCs and industrial robots, enabling them to perform efficient and natural movements.

[1813] "Terminal means" refers to a device used by a user to make settings or input data, such as a smartphone, a personal computer, or a factory control terminal.

[1814] "Server means" refers to a computer system that runs on a cloud or local server and processes, simulates, analyzes, and optimizes data.

[1815] "Behavior pattern" refers to a set of rules or algorithms that define the movements or behavior of a non-player character or industrial robot.

[1816] "Simulation" refers to the process of recreating and testing the behavioral patterns of non-player characters or industrial robots within a virtual environment.

[1817] "Optimization" refers to the process of improving inefficient or unnatural behavior based on simulation results and generating more appropriate behavioral patterns.

[1818] A "game server" refers to a server that centrally manages in-game information and processing and processes data for players and NPCs.

[1819] "Industrial systems" refers to all systems used in factories for production lines, robot control, data management, etc.

[1820] "Non-player character (NPC)" refers to a character in a game that is not controlled by the player and behaves according to programmed actions.

[1821] An "industrial robot" refers to a mechanical device that can automatically perform tasks in the production process within a factory.

[1822] The system for carrying out the present invention comprises a user terminal means, a server means, a simulation means, an optimization means, and an implementation means. A specific embodiment of the system will be described below.

[1823] First, the user logs into the system using a dedicated device (e.g., smartphone, PC, factory control terminal). After logging in, the user clicks the "Set new movement pattern" button and inputs the basic characteristics of the target non-player character (NPC) or industrial robot (e.g., movement speed, priority of various tasks, etc.). This setting data is sent from the device to the server.

[1824] The server generates an initial behavioral pattern based on the received basic characteristics. This process uses machine learning frameworks such as TensorFlow and PyTorch. For example, an industrial robot's behavioral pattern might include the task of "picking up packages from a conveyor belt and placing them on a pallet." The server generates this behavior sequence and simulates it in a virtual environment.

[1825] Simulation is the process of testing how generated behavioral patterns perform within a virtual environment. Once the simulation is complete, the simulation results are sent to a server, which analyzes the results and identifies unnatural behaviors or lack of efficiency. This analysis is performed by machine learning algorithms.

[1826] Next, the server modifies and optimizes the movement pattern based on the analysis results. For example, modifications such as "reducing the time it takes to pick up luggage" or "optimizing the speed of movement" are made. The optimized movement pattern is saved again on the server and the user is asked to confirm it.

[1827] Once the user approves the optimized motion pattern, the implementation means uploads the final behavior model to the game server or industrial system, and the implementation is completed, allowing the non-player characters and industrial robots to behave efficiently and naturally.

[1828] This system allows users to easily design, optimize, and implement behavior patterns for NPCs and industrial robots. As a concrete example, the following prompt sentences can be used:

[1829] Example prompt sentence:

[1830] "Start a simulation for the configuration where you want to optimize the robot's motion pattern. The robot will pick items and place them on a pallet. You want to reduce the time from start to finish."

[1831] When this prompt is sent to the server, a machine learning algorithm identifies areas for improvement in behavior and generates optimized patterns.The hardware used includes user devices (smartphones, PCs, factory control terminals), servers (cloud or local servers), and industrial robots (ARM robots, etc.).The software used includes server-side scripts (Python or JavaScript), machine learning frameworks (TensorFlow, PyTorch), and front-end frameworks (React, Vue.js).

[1832] The implementation of this system is expected to significantly improve the efficiency of industrial production lines and the realism of in-game NPCs.

[1833] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1834] Step 1:

[1835] A user logs in to the system using a terminal.

[1836] (Input) User authentication information (user ID, password)

[1837] (Output) Login success message and system home screen

[1838] (Specific operation) The user enters login information into the device and clicks the "Login" button. The device sends the authentication information to the server, which verifies the authentication information and displays the home screen if successful.

[1839] Step 2:

[1840] The user sets a new behavior pattern using the terminal.

[1841] (Input) Basic characteristics of a non-player character or industrial robot (speed of movement, task priority, etc.)

[1842] (Output) Setting data (JSON format, etc.)

[1843] (Specific operation) The user enters the required characteristics on the device's setting screen and clicks the "Save settings" button. The device then sends the entered setting data to the server.

[1844] Step 3:

[1845] The server generates an initial behavior pattern based on the basic characteristics.

[1846] (Input) Setting data

[1847] (Output) Initial behavior pattern (algorithm or rule set)

[1848] (Specific Operation) The server receives the configuration data and generates an initial behavioral pattern using a generative AI model (using TensorFlow or PyTorch). This generated behavioral pattern is, for example, an action sequence of "picking up luggage and placing it on a pallet."

[1849] Step 4:

[1850] The server simulates the generated behavioral patterns in a virtual environment.

[1851] (Input) Initial behavior pattern

[1852] (Output) Simulation results (log files, performance data, etc.)

[1853] (Specific operation) The server creates a virtual environment and executes the initial behavior pattern. At this time, it simulates the robot's behavior in the virtual environment in real time and records the results.

[1854] Step 5:

[1855] The server analyzes the simulation results and identifies unnatural behavior and areas for improvement.

[1856] (Input) Simulation results

[1857] (Output) Analysis results (report and recommended fixes)

[1858] (Specific operation) The server analyzes the simulation log files and performance data, and uses machine learning algorithms to identify unnatural behavior and inefficiencies.

[1859] Step 6:

[1860] The user uses the terminal to check the analysis results and correct the behavioral patterns as necessary.

[1861] (Input) Analysis results, correction parameters

[1862] (Output) Modified behavior pattern

[1863] (Specific operation) The user checks the analysis results displayed on the terminal, and if any corrections are necessary, they input the parameters and reset them. The corrected data is sent back to the server.

[1864] Step 7:

[1865] The server regenerates and optimizes the behavioral patterns based on the modified parameters.

[1866] (Input) Modified parameters

[1867] (Output) Optimized behavioral patterns

[1868] (Specific Operation) The server receives the modified parameters and generates and optimizes the behavioral pattern again. In the optimization process, a simulation is performed again to generate the optimal pattern.

[1869] Step 8:

[1870] The user approves the optimized behavior pattern and the server implements it.

[1871] (Input) Optimized behavioral patterns, user approval

[1872] (Output) Implementation completion notification

[1873] (Specific operation) The user checks the optimized behavior pattern on the device and clicks the "Approve" button. The server uploads the approved behavior pattern to the game server or industrial system and sends a notification of implementation completion to the device.

[1874] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1875] This invention relates to a system for automatically generating behavior patterns of non-player characters (NPCs), simulating and optimizing them, and implementing them in games. Furthermore, by combining this system with an emotion engine that recognizes the user's emotions and adjusts the NPC's behavior patterns based on those emotions, it provides a more realistic interactive experience.

[1876] First, the user uses the terminal to log in to the game development tool. After logging in, the user clicks the "Create a new NPC" button and sets the basic characteristics of the NPC. For example, the following characteristics can be set:

[1877] Personality: Brave

[1878] Skill: Swordsman

[1879] Reaction speed: Fast

[1880] Once the user sets these basic characteristics, the information is sent from the device to the server. The server uses this data to generate initial behavioral patterns using an AI algorithm. Behavioral scenarios based on the basic characteristics include "attack immediately when an enemy is found" and "support when an ally is found."

[1881] The generated behavioral patterns are then sent to the device and displayed to the user. After the user confirms the behavioral patterns, the server creates a virtual environment and starts the simulation. A specific simulation example is a scene where an NPC encounters an enemy in a virtual combat scenario. Once the simulation is complete, the server analyzes the results, identifies unnatural behaviors and areas for improvement, and generates a report. This report is sent to the device and displayed to the user.

[1882] Based on the report, users can modify the NPC's behavior patterns. For example, they can adjust the settings to speed up the "reaction time to finding an enemy." This modified data is sent back to the server, which then regenerates and optimizes the behavior patterns based on the new settings. After the final behavior model is generated, it is sent back to the device for user approval.

[1883] On the other hand, by using an emotion engine, it is possible to adjust behavioral patterns according to the user's emotional state. Specifically, the emotion engine installed on the device recognizes emotions from the user's facial recognition data and voice tone, and sends this data to the server. The server analyzes the received emotion recognition data and dynamically adjusts behavioral patterns, such as making NPCs more cooperative if the user is feeling stressed.

[1884] As a result, NPCs can better respond to user interactions, improving the game's realism and appeal. For example, if the user is nervous, the NPCs will act more cautiously, and if the user is relaxed, the NPCs will act more boldly.

[1885] Once the final behavioral model is approved by the user, the server uploads it to the game server and completes the implementation. Once the implementation is complete, the results are notified to the device so that the user can check them.

[1886] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic in-game experience, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[1887] The processing flow will be explained below.

[1888] Step 1:

[1889] Terminal: The user logs in to the real NPC development tool. The user enters login information and accesses the system.

[1890] Step 2:

[1891] Terminal: The user clicks the "Create a new NPC" button. The settings screen appears.

[1892] Step 3:

[1893] Terminal: The user inputs the basic characteristics of the NPC, such as personality (e.g., brave), skills (e.g., swordsman), and reaction speed (e.g., fast).

[1894] Step 4:

[1895] Terminal: Sends the entered setting data to the server. Data is sent so that the setting information reaches the server reliably.

[1896] Step 5:

[1897] Server: Receives basic characteristic data sent by the user and confirms receipt of the data.

[1898] Step 6:

[1899] Server: Uses AI algorithms to generate initial behavioral patterns based on the received basic characteristics. Specifically, it creates behavioral scenarios based on personality and skills.

[1900] Step 7:

[1901] Server: Sends the generated behavioral patterns to the terminal, and transmits the data so that the user can check it.

[1902] Step 8:

[1903] Terminal: Displays the generated behavioral pattern to the user and asks for confirmation. Provides an interface for the user to confirm the behavioral pattern.

[1904] Step 9:

[1905] User: Checks the generated behavioral patterns and instructs the simulation to start. After checking, the user issues a command to run the simulation.

[1906] Step 10:

[1907] Server: Builds a virtual environment for the simulation. Prepares the environment necessary to run the simulation.

[1908] Step 11:

[1909] Server: Starts simulating NPC behavior patterns. Checks whether the NPC performs the specified actions in the virtual environment.

[1910] Step 12:

[1911] Server: Analyzes the simulation results, identifies abnormal behavior and areas for improvement, analyzes the results, and creates reports.

[1912] Step 13:

[1913] Server: Sends simulation result reports to the terminal in a format that can be understood by the user.

[1914] Step 14:

[1915] Terminal: displays the report to the user and asks for confirmation. Shows the simulation results on the interface.

[1916] Step 15:

[1917] User: Based on the report, modify the NPC's behavior patterns. Adjust the settings according to the improvements.

[1918] Step 16:

[1919] Terminal: Sends modified parameters to the server. Ensures that new configuration information is sent to the server.

[1920] Step 17:

[1921] Server: Regenerates and optimizes behavioral patterns based on the corrected data. Creates optimal behavioral patterns using algorithms.

[1922] Step 18:

[1923] Server: Generates the final behavioral model and sends it to the device. Sends the data so that the user can check it.

[1924] Step 19:

[1925] Terminal: Displays the final behavioral model to the user for approval. Provides an interface for the user to review the final model.

[1926] Step 20:

[1927] User: Review and approve the final behavior model. Confirm the final satisfactory behavior pattern.

[1928] Step 21:

[1929] Emotion Engine: Analyzes the user's face and voice to recognize emotions, determining the user's emotional state in real time.

[1930] Step 22:

[1931] Emotion engine: Sends emotion data to the server. Enables the server to receive emotion data.

[1932] Step 23:

[1933] Server: Dynamically adjusts behavior patterns based on emotion data. Changes NPC behavior according to the user's emotions.

[1934] Step 24:

[1935] Server: Generates the final adjusted behavioral model and sends it to the device. Sends the data so that the user can check it.

[1936] Step 25:

[1937] Terminal: Displays the adjusted behavioral model to the user and asks for approval. Provides an interface for the user to confirm the adjustments.

[1938] Step 26:

[1939] User: Approves the final adjusted behavioral model. Finally, confirms the behavioral model according to the emotion.

[1940] Step 27:

[1941] Terminal: Following the user's instructions, the terminal issues an instruction to the server to implement the final behavior model on the game server. The implementation procedure begins.

[1942] Step 28:

[1943] Server: Upload the final behavioral model to the game server and complete the implementation. Integrate the data into the game server.

[1944] Step 29:

[1945] Server: Notifies the terminal that the implementation is complete. Informs the terminal of the success or failure of the implementation.

[1946] Step 30:

[1947] Terminal: Display a notification to the user that the implementation is complete. Notify the user that all processing has been completed successfully.

[1948] In this way, the Real NPC Development Tool can efficiently generate, simulate, and optimize NPC behavior models based on user settings and emotions, and then implement them in the game.

[1949] Example 2

[1950] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1951] In conventional game systems, the process of generating and optimizing the behavior patterns of non-player characters (NPCs) is often done manually, placing a heavy burden on developers. Furthermore, it is difficult to dynamically adjust NPC behavior based on user emotions, limiting the interactive experience. It is necessary to solve these problems and improve development efficiency and the quality of the game experience.

[1952] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1953] In this invention, the server includes user interface means for allowing a user to input basic characteristics of non-player characters, data processing means for generating behavioral patterns of non-player characters based on the input basic characteristics, data processing means for simulating the generated behavioral patterns, data processing means for analyzing the simulation results and generating optimized behavioral patterns, communication means for implementing the optimized behavioral patterns, and emotion analysis means for recognizing user emotions and dynamically adjusting the behavioral patterns of non-player characters based on that data. This enables dynamic behavior adjustment in response to user emotions, making it possible to provide a realistic and engaging interactive experience while reducing the burden on developers.

[1954] "User interface means" refers to an input device and a display device that allow a user to input basic characteristics and modification parameters of a non-player character.

[1955] "Data processing means" refers to a device that executes algorithms or programs to generate, simulate, analyze and optimize behavioral patterns based on received data.

[1956] "Communication means" refers to the network interface and protocol for uploading and implementing optimized behavioral patterns to the game server.

[1957] "Emotion analysis means" refers to software and hardware for recognizing emotions from a user's facial recognition data and voice tone and analyzing that data.

[1958] "Virtual environment" refers to a simulated environment constructed to test and evaluate the behavioral patterns of non-player characters.

[1959] "Non-player characters" refer to characters that appear in the game and act separately from the user.

[1960] A "behavior pattern" refers to a series of actions or reactions that a non-player character performs in a particular situation.

[1961] "Simulation" refers to the process of replicating the behavioral patterns of non-player characters within a virtual environment and evaluating their actions.

[1962] "Basic characteristics" refers to the initial attributes of a non-player character, such as personality, skills, reaction speed, etc.

[1963] "Parameters" refer to numerical values ​​and settings used to control and adjust the behavior patterns of non-player characters.

[1964] This invention is a system that automatically generates behavior patterns for non-player characters (NPCs) and implements them in a game through simulation and optimization. Furthermore, it combines an emotion engine that recognizes user emotions and dynamically adjusts NPC behavior patterns based on those emotions to provide a more realistic interactive experience. The following describes in detail the embodiments of this invention.

[1965] Hardware and software used

[1966] Hardware:

[1967] Terminal (including user interface means)

[1968] Server (including data processing means and communication means)

[1969] Camera and microphone for emotion analysis (including emotion analysis means)

[1970] software:

[1971] Game Development Tools

[1972] AI algorithms (used for generating and optimizing behavioral patterns)

[1973] Emotion engine (analyzes user emotions)

[1974] Simulation environment construction software

[1975] Specific processing explanation of the system

[1976] User Action:

[1977] First, the user logs in to the game development tool using a terminal. After successfully logging in, the main screen appears and the user clicks the "Create a new NPC" button. The user enters the NPC's basic characteristics (e.g., personality, skills, reaction speed) in the displayed form and clicks the "Submit" button.

[1978] Data transmission and processing:

[1979] The device sends the set characteristic data to the server, which then runs an AI algorithm based on the received characteristic data to generate the NPC's initial behavior pattern. The generated behavior pattern is then sent back to the device and displayed to the user.

[1980] Simulation and optimization:

[1981] The server creates a virtual environment and simulates the generated behavior patterns, such as an NPC encountering an enemy in a virtual combat scenario. The simulation results are analyzed by the server to identify unnatural behaviors and areas for improvement, and a report is generated. This report is sent to the device and displayed to the user.

[1982] Behavioral pattern modification and regeneration:

[1983] The user can then modify the NPC's behavior based on the report and send the modified data back to the server. The server then re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing the behavior. Once the final behavior model is generated, it is sent back to the device for user approval.

[1984] Dynamic adjustment with emotion engine:

[1985] The device runs an emotion engine that analyzes the user's emotions based on facial recognition data, voice tone, etc. The analyzed emotion data is sent to a server, which then dynamically adjusts the NPC's behavior patterns based on the user's emotional state. For example, if the user is stressed, the NPC will behave more cooperatively, and if the user is relaxed, the NPC will behave more boldly.

[1986] Example prompt sentence:

[1987] Generate a new NPC's behavioral pattern. Consider the following characteristics:

[1988] Personality: Brave

[1989] Skill: Swordsman

[1990] Reaction speed: Fast

[1991] Examples of behavioral patterns include 'attack immediately when you spot an enemy' and 'support when you spot an ally.'

[1992] This system allows NPCs to dynamically change according to the user's emotions, creating a more realistic interactive experience in the game, and also allows developers to efficiently adjust NPC behavior patterns, improving the quality and efficiency of game development.

[1993] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1994] Program processing flow

[1995] Step 1: User logs into game development tools

[1996] The user opens the login screen of the game development tool using the terminal, enters the username and password, and clicks the "Login" button.

[1997] Input: Username, Password

[1998] Output: Game development tool main screen

[1999] Operation: If the username and password are successfully authenticated, the main screen will be displayed.

[2000] Step 2: User initiates creation of a new NPC

[2001] The user clicks the "Create a new NPC" button on the main screen.

[2002] Input: "Create New NPC" button click event

[2003] Output: NPC basic characteristics input form

[2004] Effect: A form will appear where you can enter the NPC's basic characteristics.

[2005] Step 3: The device sends the NPC's characteristic data to the server.

[2006] The user inputs the basic characteristics of the NPC (e.g., personality, skills, reaction speed) and clicks the "Send" button. The device then sends this data to the server.

[2007] Input: NPC base characteristic data

[2008] Output: Attribute data sent to the server

[2009] Operation: The device sends the entered characteristic data to the server's API.

[2010] Step 4: The server generates the initial behavior patterns of the NPC.

[2011] Based on the characteristic data received by the server, an initial behavioral pattern is generated using a generative AI model.

[2012] Input: NPC base characteristic data

[2013] Output: Initial behavior pattern

[2014] Behavior: AI algorithms analyze characteristic data and generate behavioral patterns.

[2015] Step 5: The server sends the initial behavior pattern to the terminal and displays it to the user.

[2016] The server transmits the generated behavior pattern to the terminal, and the user confirms the behavior pattern.

[2017] Input: Initial behavior pattern

[2018] Output: Behavioral patterns displayed on the terminal

[2019] Operation: The server sends the behavioral patterns to the device and updates the UI for display.

[2020] Step 6: The server starts the simulation

[2021] After the user confirms their behavioral patterns, the server creates a virtual environment and starts the simulation, for example, simulating an NPC encountering an enemy in a virtual combat scenario.

[2022] Input: Action pattern approval instructions

[2023] Output: Simulation results

[2024] Operation: The server creates a virtual environment and executes a behavioral pattern scenario.

[2025] Step 7: The server analyzes the simulation results and generates a report

[2026] After the simulation is complete, the server analyzes the results, identifies any unusual behaviors and areas for improvement, and generates a report.

[2027] Input: Simulation result data

[2028] Output: Analysis results and reports

[2029] How it works: The server analyzes the resulting data and generates a report.

[2030] Step 8: The server sends the report to the terminal and displays it to the user.

[2031] The server sends the report to the terminal, and the user checks the contents of the report.

[2032] Input: Generated report

[2033] Output: Report displayed on terminal

[2034] What it does: The server sends the report data to the device and updates the UI for display.

[2035] Step 9: User modifies NPC behavior patterns

[2036] The user inputs the parameters of the behavioral pattern that he / she wants to modify based on the report and clicks the "Update" button.

[2037] Input: Correction parameters

[2038] Output: Correction data sent from the device to the server

[2039] Operation: The device sends the modification parameters to the server's API.

[2040] Step 10: The device sends the correction data to the server

[2041] The modified data is transmitted from the terminal to the server and received by the server.

[2042] Input: Correction parameter data

[2043] Output: Modified data stored on the server

[2044] How it works: The device sends correction data via API to the server, which receives and stores the data.

[2045] Step 11: The server recreates and optimizes the behavioral patterns

[2046] The server re-runs the AI ​​algorithm based on the new settings, regenerating and optimizing new behavioral patterns.

[2047] Input: Correction parameter data

[2048] Output: Optimized behavioral patterns

[2049] How it works: The server re-runs the AI ​​algorithms to regenerate and optimize behavioral patterns.

[2050] Step 12: The server sends the final behavior model to the terminal and asks for user approval.

[2051] Once the final behavioral model is generated, the server sends the data to the terminal and asks for the user's approval.

[2052] Input: Optimized behavioral patterns

[2053] Output: Final behavioral model displayed on the terminal

[2054] Operation: The server sends the final behavior model to the device and updates the UI for display.

[2055] Step 13: The device runs the emotion engine and recognizes the user's emotion.

[2056] The emotion engine installed in the device analyzes the user's facial recognition data and voice tone to recognize the user's emotions.

[2057] Input: User's facial recognition data, audio tone

[2058] Output: Sentiment analysis data

[2059] How it works: The device's emotion engine analyzes the input data and identifies the user's emotion.

[2060] Step 14: The server dynamically adjusts behavioral patterns based on emotion data.

[2061] Based on the received emotional data, the server dynamically adjusts the NPC's behavior patterns according to the user's emotional state.

[2062] Input: Sentiment analysis data

[2063] Output: Dynamically adjusted behavioral patterns

[2064] How it works: The server analyzes the sentiment analysis data and adjusts behavioral patterns.

[2065] Step 15: The server uploads the final behavior model to the game server.

[2066] The final behavior model approved by the user is uploaded from the server to the game server.

[2067] Input: Approved Final Behavioral Model

[2068] Output: Behavioral model implemented on the game server

[2069] Operation: The server uploads the behavior model to the game server and completes the implementation.

[2070] Step 16: The device displays a notification to the user that the implementation is complete.

[2071] Once the implementation is complete, the results are notified to the terminal and can be confirmed by the user.

[2072] Input: Implementation Completion Notification

[2073] Output: A completion notification displayed on the terminal

[2074] Action: The device receives a notification that the implementation is complete and displays it to the user.

[2075] (Application example 2)

[2076] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[2077] Conventional food delivery services have struggled to provide an experience that takes into account the emotions of customers during delivery. Furthermore, delivery by general autonomous robots lacks the ability to respond appropriately to situations where the customer is tired or relaxed, making it difficult to improve customer satisfaction.

[2078] The identification processing by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes terminal means for a user to input basic characteristics of non-player characters, server means for generating behavior patterns of non-player characters based on the input basic characteristics, server means for simulating the generated behavior patterns, server means for analyzing the simulation results and generating optimized behavior patterns, means for implementing the optimized behavior patterns on the game server, server means for recognizing the user's emotions and dynamically adjusting the behavior patterns of non-player characters in accordance with the emotions, and terminal means for recognizing the user's emotions in the autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions. This enables the autonomous delivery robot to respond in accordance with the emotions of customers, providing customers with a personalized delivery experience.

[2079] "Terminal means for the user to input the basic characteristics of a non-player character" refers to a device that allows the user to set the characteristics of a non-player character (NPC), and by which the user can input characteristics such as the personality and skills of the NPC.

[2080] The "server means for generating behavior patterns of non-player characters based on input basic characteristics" is a server for generating behavior patterns of NPCs using an algorithm based on the characteristic information of the NPCs input by the user.

[2081] The "server means for simulating the generated behavior pattern" is a server for running the generated behavior pattern of the NPC on a trial basis in a virtual environment and simulating it.

[2082] The "server means for analyzing the simulation results and generating optimized behavioral patterns" is a server for evaluating and analyzing the simulation results, correcting unnatural or inefficient behaviors, and generating optimized behavioral patterns.

[2083] "Means for implementing optimized behavior patterns on a game server" refers to means for applying optimized NPC behavior patterns within a game and making them operate in an actual game environment.

[2084] "Server means for recognizing the user's emotions and dynamically adjusting the behavioral patterns of non-player characters in accordance with those emotions" refers to a server that analyzes the user's emotional state (for example, through facial recognition or voice recognition) and adjusts the behavior of NPCs in real time based on the results.

[2085] "Terminal means for recognizing the emotions of a user in an autonomous delivery robot and adjusting the behavior of the delivery robot based on the recognized emotions" refers to a terminal that allows an autonomous food delivery robot to analyze the emotions of a customer when making a delivery and adjust the robot's behavior and greeting message according to those emotions.

[2086] This invention is a system for food delivery services in which an autonomous delivery robot recognizes the emotions of customers and dynamically adjusts its behavior in response to those emotions. This system includes a terminal means for users to set the behavior patterns of non-player characters (NPCs), a server means for performing simulations and optimization based on those behavior patterns, and a function for recognizing customer emotions and adjusting the behavior of the delivery robot.

[2087] System Configuration

[2088] 1. Terminal means

[2089] The user inputs basic characteristics of the NPC using the terminal means, such as personality, skills, reaction speed, etc.

[2090] 2. Server Means

[2091] The server means generates behavior patterns of the NPC based on the basic characteristics input by the user. The generated behavior patterns are then simulated and the simulation results are analyzed. The server optimizes the behavior patterns of the NPC based on the simulation results. The optimized behavior patterns are finally implemented on the game server.

[2092] 3. Emotion recognition and behavioral regulation

[2093] The server also has the ability to recognize the user's emotions. This is done using facial expression analysis and voice tone analysis. This allows the server to understand the user's state, such as whether they are tired or relaxed. The server dynamically adjusts the behavior of NPCs based on the recognized emotions.

[2094] 4. Delivery robots

[2095] A food delivery robot receives instructions from the server and adjusts its behavior according to the customer's emotions. For example, if the robot detects that the customer is tired, it will deliver quickly and quietly and play a message like, "Thank you for your hard work. Here's your delivery. Please relax." On the other hand, if the customer is relaxed, the robot will deliver at a normal speed and play a message like, "Thank you for your order! We'll deliver it to you soon!"

[2096] Hardware and software used

[2097] Devices: personal computers and smartphones

[2098] Server: High-performance cloud server

[2099] Emotion recognition: facial recognition software (e.g., Emotion API), voice recognition software

[2100] Delivery Robot: Autonomous robot for food delivery

[2101] Generative AI model: Behavioral pattern generation system

[2102] Specific examples

[2103] Scenario 1: A customer receives a delivery after a long day. Emotion recognition software recognizes the customer's facial expression as "tired." The delivery robot plays a message saying, "Thank you for your hard work. Here's your delivery. Please relax." and quietly makes the delivery.

[2104] Scenario 2: A customer is having a good time with friends. The emotion recognition software recognizes the customer's facial expression as "happy." The delivery robot plays a message saying, "Thank you for your order! We'll deliver it to you soon!" and delivers the package at a normal speed.

[2105] Prompt Sentence Examples

[2106] "If the customer's emotion is 'tired,' the robot will deliver quickly and quietly, playing the message, 'Thank you for your hard work. Here's your delivery. Please relax.' If the customer's emotion is 'happy,' the robot will deliver at a normal speed, playing the message, 'Thank you for your order! We'll deliver it to you soon!'"

[2107] The present invention enables the food delivery experience to be highly personalized according to the customer's emotional state, which is expected to improve customer satisfaction.

[2108] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[2109] Step 1:

[2110] The terminal allows the user to input the basic characteristics of the non-player character. At this time, the user sets characteristics such as personality, skills, and reaction speed. The terminal receives the input basic characteristics and transmits them to the server. The input data includes "brave," "swordsman," and "fast."

[2111] Step 2:

[2112] The server receives the basic characteristics sent from the device and generates initial behavior patterns for non-player characters based on that information. The server analyzes the input data and generates behavior patterns using an algorithm. The generated behavior patterns include "attack immediately when an enemy is found" and "support when an ally is found."

[2113] Step 3:

[2114] The server constructs a virtual environment to simulate the generated behavioral patterns and starts the simulation. It experimentally reproduces the behavior of non-player characters in the virtual environment and collects the results. The output of the simulation is data including, for example, "attacking an enemy in a battle scenario" and "supporting an ally."

[2115] Step 4:

[2116] The server analyzes the simulation results and identifies unnatural behaviors and areas for improvement. It then organizes the simulation data and generates optimized behavior patterns. For example, this includes adjusting reaction speed and modifying attack patterns to make them more effective. The optimized data is the optimized behavior pattern.

[2117] Step 5:

[2118] The server implements the optimized behavior pattern on the game server. After implementation, these settings are reflected in the game, and the non-player characters behave in the actual game environment. The game server then verifies that the behavior pattern has been applied correctly and notifies the terminal of the result. The output is a notification that "The behavior pattern has been implemented."

[2119] Step 6:

[2120] The device collects data through a camera and microphone to recognize the user's emotions. The collected data is sent to an emotion recognition engine that analyzes the user's facial expressions and voice tone. The input data is video and audio data.

[2121] Step 7:

[2122] The server analyzes the collected facial expression and voice tone data to identify the user's emotional state. For example, emotion recognition software is used to distinguish emotions such as "tired" or "happy." The analysis results in the recognition data such as "The user is tired."

[2123] Step 8:

[2124] The server dynamically adjusts the behavioral patterns of non-player characters based on the recognized emotional state. For example, if the user is tired, it sets the character's behavior to be more cooperative. The output is a message saying "Behavior pattern adjusted."

[2125] Step 9:

[2126] The terminal acquires the camera feed of the autonomous delivery robot and collects data that the robot can use to recognize customer emotions. The collected data is video data.

[2127] Step 10:

[2128] The server analyzes the customer's emotions based on the video data sent from the device. For example, it uses emotion recognition software to distinguish between "tired" and "happy." The analysis result is "The customer is feeling tired."

[2129] Step 11:

[2130] The server adjusts the behavior of the delivery robot based on the analysis results. For example, if the customer is tired, the delivery robot will deliver quickly and quietly and play a message saying, "Thank you for your hard work. Here's your delivery. Please relax." The output is a message saying, "Behavior adjusted."

[2131] This will enable autonomous food delivery robots to respond to customers' emotions, providing a more personalized experience.

[2132] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

[2133] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[2134] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[2135] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[2136] FIG. 9 illustrates an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and behaviors arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally ...

Claims

1. a terminal means for a user to input basic characteristics of a non-player character; a server means for generating a behavior pattern of a non-player character based on the input basic characteristics; a server means for simulating the generated behavioral patterns; a server means for analyzing the simulation results and generating an optimized behavior pattern; and means for implementing the optimized behavioral patterns on a game server.

2. a terminal means for allowing a user to input parameters necessary to modify the behavior pattern of a non-player character; 2. The system of claim 1, further comprising: server means for regenerating and optimizing the behavioral patterns based on the modified parameters.

3. 2. The system of claim 1, further comprising server means for creating a virtual environment for the simulation.

Images