system

Abstract

Provide a system. [Solution] A means for acquiring player behavior data; means for automatically generating a new scenario based on the player's behavior data; A means for transmitting the generated scenario to a player's device; A means to collect data on the scenario the player progresses through and use it to generate the next scenario, A system including:

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 traditional open-world RPGs, once a player has consumed all the content provided, there is a problem of there being nothing left to do until the next update. This can cause players to lose interest and prevent them from continuing to play the game. Furthermore, writers and engineers must constantly create new content, which makes it difficult to focus resources. Therefore, it is necessary to provide an environment where players can always enjoy new experiences. [Means for solving the problem]

[0005] The present invention is a system that includes a means for acquiring player behavior data, a means for automatically generating a new scenario based on the player behavior data, a means for transmitting the generated scenario to the player's device, and a means for collecting data on the player's progress as the scenario is generated and using it to generate the next scenario. The scenario generation means selects an appropriate template from a template database and customizes it based on the player's behavior history and current situation. Furthermore, by including a means for the player's device to receive new scenario data and notify the player, the player can constantly experience new content and maintain their motivation to continue playing the game. This system allows writers and engineers to focus on major updates and writing the main story.

[0006] "Player behavioral data" refers to information such as the series of actions and choices a player takes in the game, past quest progress, locations traveled, and conversation history with NPCs.

[0007] A "scenario" refers to the design and progression of a series of stories, events, and quests that players experience in the game.

[0008] "Auto-generation" is the process by which artificial intelligence or algorithms autonomously create new content or scenarios based on player behavioral data and other input data.

[0009] The "template database" is a database that stores various templates used to generate scenarios, including quest templates and NPC dialogue patterns.

[0010] "Notifications" refers to a series of displays or alerts that the device displays to inform the player of specific information or new scenarios.

[0011] "Action history" is a record of the actions and choices a player has made in the game, which allows us to understand the player's play style and progress.

[0012] "Customization" refers to modifying and adjusting a scenario template selected from a template database according to the behavioral history and current situation of each individual player.

[0013] A "scenario generation module" is a collection of programs and algorithms for automatically generating new scenarios based on player behavior data.

[0014] "Device" refers to the device a player uses to play the game, including computers, smartphones, tablets, etc. [Brief explanation of the drawings]

[0015] [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

[0016] 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.

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

[0018] 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).

[0019] 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.

[0020] 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.

[0021] 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.

[0022] 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."

[0023] [First embodiment]

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

[0025] 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.

[0026] 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).

[0027] 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.

[0028] 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.

[0029] 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.

[0030] 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.

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

[0032] 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.

[0033] 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.

[0034] 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.

[0035] 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."

[0036] The system of the present invention provides a process for dynamically generating sub-stories and NPC dialogue in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system allows writers and engineers to focus on writing major updates and the main story.

[0037] Server-side processing

[0038] 1. Initialize the database

[0039] When the server starts, it initializes the database and stores NPC character information, basic dialogue templates, and quest templates. For example, it registers information about villagers, enemy characters, and main characters.

[0040] 2. Acquiring player data

[0041] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[0042] 3. Generate a new scenario

[0043] The server's scenario generation module creates new scenarios based on the player's behavioral data. The algorithm selects an appropriate scenario template from a template database and customizes it to fit the player's situation.

[0044] 4. Storage and transmission of generated data

[0045] The server stores the generated scenario data in a database and transmits the data to the player's device.

[0046] Terminal side processing

[0047] 1. Requesting Data

[0048] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[0049] 2. Acquire and apply new data

[0050] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[0051] 3. Notice to Players

[0052] The device will notify the player that a new scenario or quest has been added. For example, it will display "A new quest has been added" on the UI.

[0053] 4. Storage of Player Behavior Data

[0054] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0055] User processing

[0056] 1. Play

[0057] Users play the game, converse with NPCs, and receive new sub-story quests.

[0058] 2. Quest Progression

[0059] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[0060] 3. Reporting the results

[0061] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[0062] Specific examples

[0063] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs) and customizes a scenario template that reads, "There is a problem in the village's fields." This generated scenario data is sent to the device, and new dialogue with the villager, Irene, is displayed. The user then proceeds with a new quest and solves the problem. The results are reported to the server and reflected in the next scenario generation.

[0064] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

[0065] The processing flow will be explained below.

[0066] Step 1:

[0067] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, and quest templates.

[0068] Step 2:

[0069] The device sends player behavior data requests to the server when the player moves to a new area or triggers certain events. Examples include notifications when the player arrives at a village.

[0070] Step 3:

[0071] The server receives a request from the device and retrieves the player's past behavioral data and current status from the database.

[0072] Step 4:

[0073] The server's scenario generation module selects the most suitable scenario template from the template database based on the acquired player data.

[0074] Step 5:

[0075] The server's scenario generation module customizes the selected template to suit the player's behavioral history and current situation. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs who have agricultural knowledge.

[0076] Step 6:

[0077] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[0078] Step 7:

[0079] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[0080] Step 8:

[0081] The device will notify the player that a new sub-story or quest has been added, displaying "New quest added" on the UI.

[0082] Step 9:

[0083] Users play the game and experience new scenarios and quests, where they can converse with NPCs and progress through quests.

[0084] Step 10:

[0085] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[0086] Step 11:

[0087] When a user completes a quest, the results are reported to the server via the device.

[0088] Step 12:

[0089] The server receives the player's new behavior data and stores it in a database. This data will be used to generate the next scenario.

[0090] Through these steps, the system continues to provide new content to players.

[0091] Example 1

[0092] 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."

[0093] Open-world RPGs require dynamic scenario generation methods that allow players to constantly enjoy new experiences. However, traditional systems rely on static scenarios, which can leave players with nothing to do. Furthermore, writing major updates and main stories places a heavy burden on writers and engineers.

[0094] 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.

[0095] In this invention, the server includes means for initializing a database at the start and storing non-player character information and scenario templates, means for periodically acquiring player action data and checking the current status, means for generating a new scenario based on the acquired player data, means for saving the generated scenario data in the database and transmitting it to the player's terminal, means for the player's terminal to receive the new scenario data and notify the player, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This allows players to always have new experiences in the game, and because scenarios are dynamically updated, it is possible to reduce the burden on writers and engineers.

[0096] A "server" is a computer that provides services to other computers in a network.

[0097] A "database" is a system designed to efficiently manage, store, and retrieve data.

[0098] "Non-player character information" is detailed information about in-game characters that are not controlled by the player.

[0099] A "scenario template" is a template that defines the basic structure of events and quests that occur in the game.

[0100] "Player behavior data" is a record of the actions and choices a player makes in the game.

[0101] "Status" is information that indicates the current state and abilities of a player or character.

[0102] "Scenario generation means" refers to a process or device that generates a new scenario based on player behavior data.

[0103] "Scenario data" is a set of information about the generated scenario.

[0104] A "terminal" is a device (such as a computer or smartphone) that a player uses to play a game.

[0105] A "notification means" is a method or device for notifying players that new scenarios or quests have been added.

[0106] A "collection means" is a method or device for collecting data about the scenario in which the player progresses.

[0107] A "template database" is a database in which scenario templates are stored.

[0108] "Behavior history" is a record of the actions a player has taken in the past.

[0109] MODE FOR CARRYING OUT THE INVENTION

[0110] The system of the present invention provides a process for dynamically generating sub-stories and non-player character (NPC) dialogue in an open-world RPG. This system ensures that players always have something new to experience and never run out of things to do in the game. It also provides an environment where writers and engineers can focus on writing major updates and the main story.

[0111] Server-side processing

[0112] Initializing the database

[0113] When the server starts, it initializes the database and stores NPC character information and scenario templates, including basic information and characteristics of villagers, enemies, and main characters.

[0114] Retrieving Player Data

[0115] The server periodically, or upon the player's request, retrieves player behavior data, including the player's past behavior history and current status, such as which NPCs the player has spoken to and which quests they have completed.

[0116] Generating a New Scenario

[0117] The server's scenario generation module generates new scenarios based on the acquired player data. This process involves choosing an appropriate scenario template from a template database and customizing it to fit the player's current situation. For example, if the player has previously heard about a "cursed village," the server adds that relevant information to the scenario.

[0118] Storing and sending generated data

[0119] The server stores the generated scenario data in a database and transmits the data to the player's device.

[0120] Terminal side processing

[0121] Requesting Data

[0122] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the device requests the server to generate a new scenario.

[0123] Acquiring and Applying New Data

[0124] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[0125] Player Notification

[0126] The device will notify the player that a new scenario or quest has been added. The notification will appear in the UI as "New quest added."

[0127] Player behavior data storage

[0128] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0129] User-side processing

[0130] Play

[0131] Users play the game, converse with NPCs, and take on new side story quests.

[0132] Quest Progression

[0133] Users progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[0134] Reporting the results

[0135] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[0136] Specific examples

[0137] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs). Based on this data, it customizes a scenario template for "problems occurring in the village fields" and sends the generated scenario data to the device. The device receives this data and displays new dialogue with the villagers in the game. The user then proceeds with a new quest and solves the problems in the village fields. The results are reported from the device to the server and reflected in the next scenario generation.

[0138] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

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

[0140] Step 1: Initialize the database

[0141] When the server starts, it initializes the database and stores NPC character information and scenario templates. The input data includes basic information about non-player characters and scenario templates. Specifically, the server registers information about villagers, enemy characters, and main characters in the database, and saves scenario templates such as "There is a problem in the village fields." The initialized database is generated as output.

[0142] Step 2: Get Player Data

[0143] The server retrieves player behavior data periodically or upon player request. The input includes the player's past behavior history and current status. The server collects which NPCs the player has spoken to and which quests they have completed. This updates the player's behavior history data. The output is the updated player data.

[0144] Step 3: Generate a new scenario

[0145] The server's scenario generation module generates a new scenario based on the acquired player data. The inputs include the player's behavior data and a template database. Specifically, the server selects an appropriate scenario template and customizes it based on the player's current situation. For example, it can fine-tune the scenario using information the player previously heard about the "cursed village." The output is new, customized scenario data.

[0146] Step 4: Save and send generated data

[0147] The server saves the generated scenario data in a database and sends it to the player's device. The input includes the generated scenario data. In concrete terms, the server saves the scenario data in a database and sends it to the player's device via the network. The output is the updated database and the sent scenario data.

[0148] Step 5: Request the data

[0149] The device sends a data request to the server when the player triggers a specific event. The input includes a specific event, such as the player arriving at a village. The specific operation is that the device detects this event and sends a request to the server to generate a new scenario. The output is a request to the server.

[0150] Step 6: Acquire and apply new data

[0151] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. The input includes the scenario data sent from the server. Specifically, the device receives this data and reflects it on the game screen. For example, it might display new quest information about a problem with the village's fields. The output is the new scenario applied to the player.

[0152] Step 7: Notify players

[0153] The device notifies the player that a new scenario or quest has been added. The input contains new scenario data. The specific behavior is to display a notification on the device's UI saying "A new quest has been added." The output is to notify the player of the new information.

[0154] Step 8: Storing Player Behavior Data

[0155] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server. The input includes the player's behavioral data. Specifically, the device records the player's behavior and periodically uploads it to the server. The output is the behavioral data stored on the server.

[0156] Step 9: Develop the scenario and report the results

[0157] The player progresses through the quest and reports the results to the server via the device. The input includes the player's quest progress data and result data. Specifically, the device sends the quest completion data to the server, which is reflected in the next scenario generation. The output is updated server data and data to be used in the next scenario generation.

[0158] (Application example 1)

[0159] 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."

[0160] Currently, food delivery services face challenges in providing optimal recommendations and promotions to users. Many services make recommendations based on simple rules, which lack personalization based on individual user preferences and circumstances, preventing improvements to the user experience and maximizing sales. It is also difficult to dynamically generate promotions based on seasons and events.

[0161] 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.

[0162] In this invention, the server includes a means for acquiring player behavior data, a means for automatically generating new scenarios, and a means for transmitting the generated scenarios to the player's terminal, which enables the dynamic generation of personalized recommendations and promotions based on the user's order history and current situation.

[0163] "Player behavior data" refers to information including the player's past behavior history and current status in the game.

[0164] "New scenarios" are new events and quests that players experience in the game, automatically generated based on player behavioral data.

[0165] A "terminal" is a device (such as a PC, smartphone, or game console) that a player uses to control the game.

[0166] A "template database" is a data storage system that stores multiple scenario and dialogue templates in advance.

[0167] "Order history" is data that records details of orders placed by a user in the past.

[0168] "Current conditions" are external conditions that change in real time, such as the user's current geographic location, weather information, time of day, etc.

[0169] "Personalized recommendations" are suggestions that are customized based on a user's individual preferences and behavioral history.

[0170] "Promotion" means providing special offers or discounts to encourage the purchase of a particular product or service.

[0171] "Scenario generation means" refers to algorithms and computing resources for automatically generating new scenarios based on player behavior data.

[0172] Overall structure

[0173] The present invention includes a food delivery system that dynamically generates personalized recommendations and promotions based on a user's ordering history and current circumstances.

[0174] Server-side processing

[0175] 1. Initialize the database

[0176] The server initializes a database at startup and stores user information, food menus, and promotion templates. This database contains, for example, the categories of each food and the history of past promotions. This database uses a database management system such as MySQL (registered trademark) or PostgreSQL.

[0177] 2. Obtaining user data

[0178] The server periodically, or upon user request, retrieves the user's order history and current status (e.g., geographic location, weather information). This data may include the user's preferred dishes, the region they live in, the current time zone, etc.

[0179] 3. Generate a new promotion

[0180] The server's scenario generation module creates new promotions based on user data, using a generative AI model (e.g., OpenAI's GPT-4) to customize promotions based on appropriate templates.

[0181] 4. Storage and transmission of generated data

[0182] The server stores the generated promotion data in a database and sends it to the user's device, so that the new promotion is available the next time the user opens the app.

[0183] Terminal side processing

[0184] 1. Requesting Data

[0185] The device sends a data request to the server when the user accesses the app. For example, if the user opens the app during a certain time of day, a request is automatically sent to generate promotions relevant to that time of day.

[0186] 2. Acquire and apply new data

[0187] The device receives the promotion and menu recommendation data sent from the server and applies it to the user. Specifically, new promotions are displayed on the user's screen.

[0188] 3. Notice to Users

[0189] The device will notify the user when new promotions or recommended dishes are added. For example, by using an in-app pop-up notification or push notification to inform the user that "We have a new promotion!"

[0190] User processing

[0191] 1. Use

[0192] A user uses the app to see new recommendations and promotions, for example by tapping on a promotion banner displayed within the app to learn more.

[0193] 2. Use of Promotions

[0194] A user orders food using a new promotion, such as a free garlic bread promotion with any pizza order.

[0195] 3. Reporting the results

[0196] The user's order details are sent to the server and used to generate the next promotion, which allows the user's preferences and behavior to be reflected in the next offer, providing a more personalized experience.

[0197] Examples and prompts

[0198] As a concrete example, if a user has frequently ordered pizza in the past, we can use prompt sentences like the following to feed the generative AI model:

[0199] Example prompt sentence:

[0200] The user's past order history is as follows:

[0201] 1. Pizza Margherita

[0202] 2. Seafood Pizza

[0203] Create a new promotion that your users will be interested in. Generate specific promotion details, descriptions, and applicable conditions.

[0204] Based on this prompt, the Generator AI will generate a promotion like this:

[0205] Promotion details: "For a limited time only! Get a free side dish with any pizza order."

[0206] Description: "Order a Pizza Margherita or Seafood Pizza and get a free side like garlic bread or chocolate cake."

[0207] Conditions apply: "This is a limited time offer. Orders placed by the end of this week are eligible."

[0208] The generated promotions are sent to the user's smartphone and can be notified to the user through the app's notification function. The user can then check the promotions and place an order within the app.

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

[0210] Step 1:

[0211] Initializing the database

[0212] The server initializes the database when the system starts up. Here, user information, food menus, past promotion templates, etc. are registered in a database management system such as MySQL or PostgreSQL. Specifically, SQL queries are used to create tables that store information about users, food, and promotions.

[0213] Input: Database schema information

[0214] Output: initialized database

[0215] Step 2:

[0216] Retrieving User Data

[0217] The server periodically, or upon user request, retrieves the user's order history and current status from the database. The order history includes the dishes previously ordered and the order date and time. The current status includes the geographic location and weather information. Specifically, this information is retrieved from the database using SQL queries.

[0218] Input: User ID, relevant status information

[0219] Output: User's order history, current status

[0220] Step 3:

[0221] Generate a new promotion

[0222] The server's scenario generation module generates new promotions based on the user's order history and current status. A generative AI model (e.g., GPT-4) is used for generation. Specifically, the order history and status information are input to the AI ​​as prompts, and the response from the AI ​​is obtained as a promotion.

[0223] Input: User's order history, current status

[0224] Output: The newly generated promotion

[0225] Step 4:

[0226] Storing and sending generated data

[0227] The server stores the generated promotion data in a database and transmits the data to the user's device by inserting the promotion data into the database using an SQL query and then transmitting it to the device using a REST API or other data communication method.

[0228] Input: The newly generated promotion

[0229] Output: Saved promotion data, Sent promotion data

[0230] Step 5:

[0231] Requesting Data

[0232] When a user accesses an app, the device sends a data request to the server. This is a request to obtain information related to the user's current status. Specifically, it uses an HTTP request to request the necessary data from the server.

[0233] Input: User action

[0234] Output: Data request to the server

[0235] Step 6:

[0236] Acquiring and Applying New Data

[0237] The device receives the promotion and recommended menu data sent from the server and applies it to the user. Specifically, it displays the received data in the app's UI and notifies the user in an appropriate format.

[0238] Input: Promotion data sent from the server

[0239] Output: Display of data on user terminal

[0240] Step 7:

[0241] User Notification

[0242] The device will notify users when new promotions or recommended dishes have been added, using push notifications or in-app pop-ups to inform users of the new information.

[0243] Input: New promotion data

[0244] Output: User notification

[0245] Step 8:

[0246] Reporting the results

[0247] When a user places an order using a new promotion, the result is reported to the server, which sends the order details to the server and stores them in a database for use in generating the next promotion.

[0248] Input: Order details

[0249] Output: Stored order data, reflected in next promotion generation

[0250] 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.

[0251] The system of the present invention is equipped with a process for dynamically generating sub-stories and NPC dialogue based on player behavioral and emotional data in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system provides an environment where writers and engineers can focus on writing major updates and the main story. Furthermore, by combining it with an emotion engine that recognizes user emotions, it is possible to provide content that is more tailored to the player.

[0252] Server-side processing

[0253] 1. Initialize the database

[0254] When the server starts, it initializes the database, storing NPC character information, basic dialogue templates, quest templates, and data for the emotion engine. For example, it registers information about villagers, enemies, and main characters.

[0255] 2. Acquiring player data

[0256] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[0257] 3. Acquiring Emotion Data

[0258] The server's emotion engine collects emotion data from the player's device, which is inferred from the player's facial expressions, tone of voice, and selected options.

[0259] 4. Generate a new scenario

[0260] The server's scenario generation module selects the most suitable scenario template from a template database based on the acquired player's behavioral data and emotional data.

[0261] 5. Customizing the scenario

[0262] The server's scenario generation module customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs with agricultural knowledge and situations in which the player is surprised.

[0263] 6. Storage and transmission of generated data

[0264] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[0265] Terminal side processing

[0266] 1. Requesting Data

[0267] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[0268] 2. Acquire and apply new data

[0269] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[0270] 3. Notice to Players

[0271] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[0272] 4. Acquiring Emotion Data

[0273] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[0274] 5. Storage of Player Behavior Data

[0275] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0276] User processing

[0277] 1. Play

[0278] Users play the game, converse with NPCs, and receive new sub-story quests.

[0279] 2. Quest Progression

[0280] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[0281] 3. Reporting the results

[0282] Once the user completes the quest, the results are reported back to the server via the device.

[0283] In this way, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, it is possible to provide players with more appropriate difficulty levels and content.

[0284] The processing flow will be explained below.

[0285] Step 1:

[0286] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, quest templates, and data for the emotion engine.

[0287] Step 2:

[0288] When the player moves to a new area or triggers a specific event, the device sends a request to the server for the player's behavioral and emotional data.

[0289] Step 3:

[0290] The server receives requests from the device and obtains the player's past behavioral data, current status, and emotional data from the emotion engine. Specifically, it obtains information such as which NPCs the player has spoken to in the past, which quests they have completed, and the player's current emotional state (such as surprise, joy, sadness, etc.).

[0291] Step 4:

[0292] The server's scenario generation module selects the most appropriate scenario template from the template database based on the acquired player data and emotion data. For example, if the player is interested in agriculture, it will select an agriculture-related scenario.

[0293] Step 5:

[0294] The server's scenario generation module customizes the selected template based on the player's behavioral history and emotional data. For example, if the player has the emotion "surprise," it will add a surprise element to the scenario.

[0295] Step 6:

[0296] The server stores the generated scenario data in a database and transmits it to the device, adjusting the difficulty and content according to the player's emotions.

[0297] Step 7:

[0298] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[0299] Step 8:

[0300] The device notifies the player that a new sub-story or quest has been added. The UI displays "A new quest has been added," and also displays a message based on the player's emotion.

[0301] Step 9:

[0302] The device collects emotional data such as the player's facial expressions and voice in real time and sends it to the emotion engine on the server, which continuously monitors the player's current emotional state.

[0303] Step 10:

[0304] Users play the game and experience new scenarios and quests, where they can converse with NPCs and take action to solve problems.

[0305] Step 11:

[0306] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[0307] Step 12:

[0308] When a user completes a quest, the results are reported to the server via the device, including the player's quest progress, choices, and emotional changes.

[0309] Step 13:

[0310] The server receives the player's new behavioral and emotional data and stores it in a database. This data will be used to generate the next scenario.

[0311] Through these steps, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, the system can provide players with more appropriate difficulty levels and content.

[0312] Example 2

[0313] 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."

[0314] In traditional open-world RPGs, it was difficult to generate dynamic scenarios based on the player's actions and emotions, which meant that players would quickly run out of things to do. Additionally, writing major updates and main stories required a significant amount of effort, placing a heavy burden on game developers. Furthermore, it was difficult to provide content that responded to the player's emotions, making it impossible to provide the optimal gaming experience for players.

[0315] 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.

[0316] In this invention, the server includes means for acquiring player behavioral data, means for acquiring player emotional data, means for automatically generating a new scenario based on the player behavioral data and emotional data, means for customizing the new scenario based on the player's behavioral history and current situation, means for transmitting the generated scenario to the player's device, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This makes it possible to provide players with constantly new experiences and create an environment where game developers can focus on the main story and updates.

[0317] "Player behavioral data" refers to the actions and choices a game player takes in the game, and the information obtained as a result of those actions and choices, including locations visited, enemies defeated, items acquired, and quest progress.

[0318] "Player emotional data" refers to data that indicates the emotional state that a player expresses while playing a game. Specifically, it includes data that is estimated from the player's facial expressions and tone of voice.

[0319] A "scenario" is the story or plot of events that unfolds within a game, including the goals the player must achieve and the dialogue they will have with non-player characters (NPCs).

[0320] The "template database" is a database that stores the basic frameworks and templates of various scenarios. An appropriate scenario template is selected from this database, and then customized based on the behavioral and emotional data of individual players.

[0321] "Device" refers to the electronic device used by a player to play a game, including personal computers, smartphones, and game consoles.

[0322] The "emotion engine" is a software module that analyzes the player's emotional data and estimates their emotional state, making it possible to provide the player with optimal scenarios and content.

[0323] In this invention, "means" refers to a series of processes or devices for realizing a specific function. In this case, this refers to "means for acquiring player behavior data" and "means for automatically generating new scenarios."

[0324] The present invention is a system for dynamically generating sub-stories and NPC dialogue based on player behavioral data and emotional data in an open-world RPG.

[0325] Server-side processing

[0326] The server first initializes the database. Here, a database system such as MongoDB or MySQL is used to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. Specifically, information about a character called "Villager A" and profiles of enemy characters are registered.

[0327] Next, the server retrieves the player's behavioral data. This is done periodically or upon the player's request. An API is provided to store the player's behavioral history and current status. The behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[0328] The server's emotion engine receives facial recognition data and voice tone analysis data sent from the player's device using OpenCV or Google® Cloud Speech-to-Text API, and sends the data to the API endpoint "POST / emotion_data".

[0329] Using the acquired behavioral and emotional data, the scenario generation module selects an appropriate scenario template from the template database. For example, it filters the data based on the player data for "recent_quest_type=agriculture" and selects a scenario that matches the "surprised" emotion.

[0330] The selected template is customized based on the player's behavioral history and current situation. For example, a base scenario in which "there is a problem in the village's fields" can be customized based on information from "past conversations the player has had with NPCs with agricultural knowledge" to "a new species of pest has appeared. By talking to the agricultural expert from a previous conversation, a surprising solution will be discovered."

[0331] The generated scenario is saved in the database and sent to the terminal using "POST / new_scenario".

[0332] Terminal side processing

[0333] The device sends a data request to the server when the player triggers a specific event. For example, by issuing a request such as "GET / generate_scenario?event=village_arrival", the device requests the generation of a new scenario.

[0334] The device that receives the new scenario data from the server applies it to the player. Specifically, the device displays the quest information in the game, saying, "There is a problem in the village fields."

[0335] To notify players that a new scenario has been added, the device will notify them with a pop-up notification and a UI change that says "A new quest has been added."

[0336] To capture the player's facial and voice data, the device uses a webcam and microphone and sends this data to the server's emotion engine. Using OpenCV and speech recognition APIs, the data is sent to "POST / emotion_data".

[0337] When a player progresses through a quest or talks with an NPC, their behavioral data is collected on the device and uploaded to the server. This data is sent to the server as "POST / action_data".

[0338] User processing

[0339] The user plays the game, talks to NPCs, and receives new sub-story quests. For example, the user talks to a villager and learns that "there is a problem in the village's fields."

[0340] The user progresses through the quest and takes actions to achieve the specified goal, for example, solving a problem in the fields at the request of a villager.

[0341] When the user completes a quest, they report the result to the server via their device. By pressing the quest end button, the completion status is sent to the server.

[0342] Examples and prompts

[0343] For example, when a player arrives at a village, the device sends a request to the server to "generate a new scenario." The server selects and adjusts the scenario "There is a problem in the village's fields" based on the player's behavioral and emotional data. The scenario is sent to the device and displayed as a new quest on the player's screen.

[0344] An example of a prompt sentence would be, "The player has arrived at the village fields. In the past, he has had a conversation with an NPC who has knowledge of agriculture. The player is now surprised. Please generate the next development." By inputting this into the generation AI model, a scenario and NPC lines can be generated.

[0345] This completes the implementation of the present invention. This system allows players to enjoy a constant stream of new adventures, and allows game developers to focus on major updates and storylines.

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

[0347] Step 1:

[0348] Initializing the database

[0349] The server initializes a database such as MongoDB or MySQL. Specifically, it creates tables to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. For example, it registers basic information about a character called "Villager A" and profiles for enemy characters.

[0350] Input: None

[0351] Output: initialized database, initial data stored

[0352] Specific operation: Executes the SQL statement "INSERT INTO NPCs (name, role, backstory) VALUES ('Villager A', 'farmer', 'He is...')".

[0353] Step 2:

[0354] Retrieving Player Data

[0355] The server retrieves player behavior data periodically or upon player request. An API is provided to store the player's behavior history and current status. Behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[0356] Input: API request (e.g. "GET / player_data?player_id=12345")

[0357] Output: Player behavior data

[0358] Specific operation: The server receives a request to the API endpoint and retrieves data from the database using the corresponding SQL statement.

[0359] Step 3:

[0360] Acquiring emotion data

[0361] The server's emotion engine receives facial expression recognition data and voice tone analysis data sent from the player's device. The data is sent to the API endpoint "POST / emotion_data" using OpenCV and Google Cloud Speech-to-Text API.

[0362] Input: Emotion data (e.g., facial expression recognition data, voice tone analysis data)

[0363] Output: Player emotion data

[0364] Specific operation: The device acquires data using the webcam and microphone and sends an API request to the server.

[0365] Step 4:

[0366] Generating a New Scenario

[0367] The scenario generation module selects the optimal scenario template based on the player's behavioral and emotional data acquired, and filters and selects appropriate templates from the template database.

[0368] Input: Player behavior data, player emotion data

[0369] Output: Selected scenario template

[0370] Specific behavior: Execute a query like "SELECT FROM templates WHERE recent_quest_type='agriculture' AND emotion='surprised'" to select templates.

[0371] Step 5:

[0372] Customizing the Scenario

[0373] The server customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, it customizes a scenario template that says, "There is a problem in the village's fields."

[0374] Input: Scenario template, player behavior history, emotional data

[0375] Output: Customized scenario

[0376] Specific operation: Based on information from past conversations the player had with NPCs with agricultural knowledge, a scenario such as "A new species of pest has appeared in the village fields" is generated.

[0377] Step 6:

[0378] Storing and sending generated data

[0379] The server saves the generated scenario data in a database and sends it to the terminal in the form of "POST / new_scenario".

[0380] Input: Customized scenario

[0381] Output: Data sent to the device, saved scenario data

[0382] Specific operation: Executes the SQL statement "INSERT INTO generated_scenarios (scenario_data) VALUES ('...')" and saves it in the database. Then, sends the scenario data to the terminal.

[0383] Step 7:

[0384] Data request (terminal side)

[0385] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, it issues a request like "GET / generate_scenario?event=village_arrival".

[0386] Input: Player actions (specific events)

[0387] Output: Data request to the server

[0388] Specific operation: Automatically send requests to the server according to the player's event triggers.

[0389] Step 8:

[0390] Acquiring and applying new data (terminal side)

[0391] The terminal receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. Specifically, it receives new quest information such as "There is a problem in the village fields."

[0392] Input: Scenario data from the server

[0393] Output: New scenario displayed in game

[0394] Specific operation: Display the received scenario data in the game and notify the player of new sights.

[0395] Step 9:

[0396] Notification to player (device side)

[0397] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[0398] Input: Scenario data received from the server

[0399] Output: Player notification

[0400] Specific behavior: Notify the player of the existence of a new scenario via a pop-up notification or UI change.

[0401] Step 10:

[0402] Acquiring emotion data (device side)

[0403] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[0404] Input: Player's facial expression data, voice data

[0405] Output: Emotion data, sent to the server

[0406] Specific operation: Emotion data is collected using a webcam or microphone and sent to the server via an API request.

[0407] Step 11:

[0408] Saving player behavior data (device side)

[0409] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0410] Input: Player behavior data

[0411] Output: Upload data to the server

[0412] Specific operation: Sends action data (e.g., quest completion status) to the server using "POST / action_data".

[0413] The above is the specific operation and data flow at each processing step. This series of processes ensures that players always enjoy new adventures and experiences, and allows game developers to focus on the main story and updates.

[0414] (Application example 2)

[0415] 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."

[0416] Conventional open-world RPGs and virtual store systems can only provide users with static scenarios and product recommendations, and lack dynamic experiences based on individual behavioral data and real-time emotional data. This can lead to users gradually feeling stale and losing interest. To solve this problem, a system is needed that utilizes user behavioral and emotional data to provide more personalized, dynamic scenarios and product recommendations.

[0417] The specific processing by the specific 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 means for acquiring player behavior data, means for automatically generating a new scenario based on the player behavior data and emotion data, means for transmitting the generated scenario to the player's device, means for collecting data on the scenario as the player progresses and using it to generate the next scenario, and means for recognizing the user's emotions and dynamically generating specific product suggestions and dialogue from store staff based on those emotions. This makes it possible to constantly provide new experiences and sustain the user's interest.

[0418] "Player behavior data" refers to information regarding the actions, such as various operations, movements, selections, and conversations, that a player performs within a game or virtual store.

[0419] "Emotion data" refers to information about emotions and their changes that are estimated from the player's or user's facial expressions, voice, and behavioral tendencies.

[0420] A "scenario" refers to the quests and story that the player progresses through in the game, or the user's purchasing experience and dialogue in the virtual store.

[0421] A "server" is a set of devices and systems that receive and process data sent by players or users, generate the necessary information and content, and send it to the player's or user's terminal.

[0422] A "terminal" is a computer, smartphone, smart glasses, head-mounted display, or other device used by a player or user.

[0423] "Automatic generation" refers to the process of using pre-set algorithms or AI to generate new scenarios, product suggestions, lines, etc. based on data, without manual operation.

[0424] The "template database" is a database that stores multiple templates that serve as the basis for scenarios, product proposals, and dialogue, and can be selected and customized as needed.

[0425] "Real-time" refers to the time characteristics in which data is processed to respond immediately to the actions and emotions of the player or user.

[0426] The system of the present invention dynamically generates new scenarios and product suggestions based on user behavioral and emotional data in open-world RPGs and virtual stores, providing users with constantly new experiences. This system allows users to enjoy games and shopping without getting bored.

[0427] Server-side processing

[0428] The server includes the following means:

[0429] 1. Initialize the database:

[0430] At startup, the server initializes a database and stores data for NPC character information, scenario templates, product catalogs, and emotion engines, such as registering various product categories and staff speech templates.

[0431] 2. Acquiring Player and User Data:

[0432] The server periodically or upon user request retrieves behavioral data, including past behavior history and current status.

[0433] 3. Acquiring emotion data:

[0434] The server's emotion engine acquires emotion data from the user's device, which is estimated from the user's facial expressions and tone of voice.

[0435] 4. Generate new scenarios and product proposals:

[0436] The server's scenario generation module selects the most suitable template from a template database based on the acquired user behavioral data and emotion data.

[0437] 5. Customization of scenarios and product offers:

[0438] The server's scenario generation module customizes the selected template based on the user's behavioral history and emotional state.

[0439] 6. Storage and transmission of generated data:

[0440] The server stores the generated scenarios and product proposals in a database and transmits them to the user's terminal.

[0441] Terminal side processing

[0442] The terminal includes the following means:

[0443] 1. Request for Data:

[0444] Send a data request to the server when a user triggers a specific action, for example, requesting new product suggestions when the user approaches a specific shelf.

[0445] 2. Acquire and apply new data:

[0446] Receives the latest scenarios and product suggestions sent from the server and applies them to the user, for example, notifying them that "New sneakers have arrived and are available at a special price."

[0447] 3. Notice to Users:

[0448] Notify the user that new scenarios or products have been added. Display "New products have been added" on the UI (user interface).

[0449] 4. Acquiring emotion data:

[0450] A facial recognition camera and microphone are used to capture the user's emotional data and send it to the server.

[0451] 5. Storage of User Behavior Data:

[0452] Data is collected when users purchase products or move around the store and uploaded to a server.

[0453] User processing

[0454] The user follows these steps:

[0455] 1. Shopping Experience:

[0456] A user puts on smart glasses and walks around a virtual store.

[0457] 2. Product browsing and selection:

[0458] Users can browse dynamic product suggestions and select products they are interested in. For example, when a user approaches a particular shelf, they might see a message saying, "We recommend these new sneakers."

[0459] 3. Purchasing decision:

[0460] Select your product and complete the purchase process.

[0461] Hardware and software used

[0462] Hardware: Smart glasses (e.g., Google Glass®, Vuzix Blade), facial recognition camera, microphone.

[0463] Software: Emotion recognition algorithms (e.g., OpenCV, Affectiva), scenario generation AI (e.g., GPT-3 (registered trademark)).

[0464] Prompt Sentence Examples

[0465] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

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

[0467] Step 1:

[0468] The server initializes the database. At startup, the server stores NPC character information, scenario templates, product catalogs, and data for the emotion engine in the database. The input is the initial setting data, and the output is the initialized database.

[0469] Step 2:

[0470] The server acquires user behavioral data. At specific times or in response to a user request, the server acquires the user's past behavioral history, purchase history, and browsing history. The input is a request to acquire user behavioral data, and the output is the behavioral data. Data processing involves reading log files and querying databases.

[0471] Step 3:

[0472] The server acquires the user's emotional data. The server's emotion engine identifies emotions by analyzing facial expression and voice data sent from the user's device. The input is the facial expression and voice data acquired from the device, and the output is the analyzed emotional data. Image processing and voice analysis are performed as data processing.

[0473] Step 4:

[0474] The server generates new scenarios and product proposals. The scenario generation module takes the user's behavioral and emotional data as input and selects the optimal template from the template database. The output is a custom scenario or product proposal based on the selected template. Template selection and customization processing are performed as data calculations.

[0475] Step 5:

[0476] The server customizes the generated scenarios and product proposals. Specific proposals and scenarios are adapted based on the user's behavioral history and emotional state. The input is the selected template, the user's behavioral history, and emotional data, and the output is a customized scenario or product proposal. Conditional branching and text generation are performed within the program.

[0477] Step 6:

[0478] The server stores the generated data and sends it to the terminal. The input is a customized scenario or product proposal, and the output is the stored generated data and the data sent to the terminal. The transmission is performed using a data transmission protocol.

[0479] Step 7:

[0480] The device sends a data request to the server. When the user triggers a specific action, the device sends a request for new data to the server. The input is the user's operation and the output is the data request.

[0481] Step 8:

[0482] The device receives new data and applies it. It receives the latest scenario and product proposal data sent from the server and applies it to the user. The input is data from the server, and the output is the applied scenario or product proposal. After data analysis, it is reflected in the UI.

[0483] Step 9:

[0484] The terminal notifies the user. The addition of a new scenario or product is displayed on the UI. The input is the data received from the server, and the output is a notification to the user. The UI is updated to notify the user.

[0485] Step 10:

[0486] The device acquires emotion data and sends it to the server. The device uses a facial recognition camera and microphone to acquire the user's facial expressions and voice, and sends the emotion data to the server in real time. The input is the acquired emotion data, and the output is the data sent to the server. This includes the processes of collecting and sending emotion data.

[0487] Step 11:

[0488] The device stores user behavior data and sends it to the server. Data is collected when the user purchases products or moves around the store and uploaded to the server. The input is the user behavior data, and the output is the data sent to the server. This includes the data collection and transmission process.

[0489] Prompt Sentence Examples

[0490] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

[0491] 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.

[0492] 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.

[0493] 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.

[0494] [Second embodiment]

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

[0496] 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.

[0497] 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).

[0498] 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.

[0499] 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.

[0500] 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).

[0501] 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. 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.

[0502] 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.

[0503] 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.

[0504] 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.

[0505] 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.

[0506] 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."

[0507] The system of the present invention provides a process for dynamically generating sub-stories and NPC dialogue in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system allows writers and engineers to focus on writing major updates and the main story.

[0508] Server-side processing

[0509] 1. Initialize the database

[0510] When the server starts, it initializes the database and stores NPC character information, basic dialogue templates, and quest templates. For example, it registers information about villagers, enemy characters, and main characters.

[0511] 2. Acquiring player data

[0512] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[0513] 3. Generate a new scenario

[0514] The server's scenario generation module creates new scenarios based on the player's behavioral data. The algorithm selects an appropriate scenario template from a template database and customizes it to fit the player's situation.

[0515] 4. Storage and transmission of generated data

[0516] The server stores the generated scenario data in a database and transmits the data to the player's device.

[0517] Terminal side processing

[0518] 1. Requesting Data

[0519] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[0520] 2. Acquire and apply new data

[0521] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[0522] 3. Notice to Players

[0523] The device will notify the player that a new scenario or quest has been added. For example, it will display "A new quest has been added" on the UI.

[0524] 4. Storage of Player Behavior Data

[0525] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0526] User processing

[0527] 1. Play

[0528] Users play the game, converse with NPCs, and receive new sub-story quests.

[0529] 2. Quest Progression

[0530] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[0531] 3. Reporting the results

[0532] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[0533] Specific examples

[0534] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs) and customizes a scenario template that reads, "There is a problem in the village's fields." This generated scenario data is sent to the device, and new dialogue with the villager, Irene, is displayed. The user then proceeds with a new quest and solves the problem. The results are reported to the server and reflected in the next scenario generation.

[0535] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

[0536] The processing flow will be explained below.

[0537] Step 1:

[0538] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, and quest templates.

[0539] Step 2:

[0540] The device sends player behavior data requests to the server when the player moves to a new area or triggers certain events. Examples include notifications when the player arrives at a village.

[0541] Step 3:

[0542] The server receives a request from the device and retrieves the player's past behavioral data and current status from the database.

[0543] Step 4:

[0544] The server's scenario generation module selects the most suitable scenario template from the template database based on the acquired player data.

[0545] Step 5:

[0546] The server's scenario generation module customizes the selected template to suit the player's behavioral history and current situation. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs who have agricultural knowledge.

[0547] Step 6:

[0548] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[0549] Step 7:

[0550] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[0551] Step 8:

[0552] The device will notify the player that a new sub-story or quest has been added, displaying "New quest added" on the UI.

[0553] Step 9:

[0554] Users play the game and experience new scenarios and quests, where they can converse with NPCs and progress through quests.

[0555] Step 10:

[0556] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[0557] Step 11:

[0558] When a user completes a quest, the results are reported to the server via the device.

[0559] Step 12:

[0560] The server receives the player's new behavior data and stores it in a database. This data will be used to generate the next scenario.

[0561] Through these steps, the system continues to provide new content to players.

[0562] Example 1

[0563] 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."

[0564] Open-world RPGs require dynamic scenario generation methods that allow players to constantly enjoy new experiences. However, traditional systems rely on static scenarios, which can leave players with nothing to do. Furthermore, writing major updates and main stories places a heavy burden on writers and engineers.

[0565] 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.

[0566] In this invention, the server includes means for initializing a database at the start and storing non-player character information and scenario templates, means for periodically acquiring player action data and checking the current status, means for generating a new scenario based on the acquired player data, means for saving the generated scenario data in the database and transmitting it to the player's terminal, means for the player's terminal to receive the new scenario data and notify the player, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This allows players to always have new experiences in the game, and because scenarios are dynamically updated, it is possible to reduce the burden on writers and engineers.

[0567] A "server" is a computer that provides services to other computers in a network.

[0568] A "database" is a system designed to efficiently manage, store, and retrieve data.

[0569] "Non-player character information" is detailed information about in-game characters that are not controlled by the player.

[0570] A "scenario template" is a template that defines the basic structure of events and quests that occur in the game.

[0571] "Player behavior data" is a record of the actions and choices a player makes in the game.

[0572] "Status" is information that indicates the current state and abilities of a player or character.

[0573] "Scenario generation means" refers to a process or device that generates a new scenario based on player behavior data.

[0574] "Scenario data" is a set of information about the generated scenario.

[0575] A "terminal" is a device (such as a computer or smartphone) that a player uses to play a game.

[0576] A "notification means" is a method or device for notifying players that new scenarios or quests have been added.

[0577] A "collection means" is a method or device for collecting data about the scenario in which the player progresses.

[0578] A "template database" is a database in which scenario templates are stored.

[0579] "Behavior history" is a record of the actions a player has taken in the past.

[0580] MODE FOR CARRYING OUT THE INVENTION

[0581] The system of the present invention provides a process for dynamically generating sub-stories and non-player character (NPC) dialogue in an open-world RPG. This system ensures that players always have something new to experience and never run out of things to do in the game. It also provides an environment where writers and engineers can focus on writing major updates and the main story.

[0582] Server-side processing

[0583] Initializing the database

[0584] When the server starts, it initializes the database and stores NPC character information and scenario templates, including basic information and characteristics of villagers, enemies, and main characters.

[0585] Retrieving Player Data

[0586] The server periodically, or upon the player's request, retrieves player behavior data, including the player's past behavior history and current status, such as which NPCs the player has spoken to and which quests they have completed.

[0587] Generating a New Scenario

[0588] The server's scenario generation module generates new scenarios based on the acquired player data. This process involves choosing an appropriate scenario template from a template database and customizing it to fit the player's current situation. For example, if the player has previously heard about a "cursed village," the server adds that relevant information to the scenario.

[0589] Storing and sending generated data

[0590] The server stores the generated scenario data in a database and transmits the data to the player's device.

[0591] Terminal side processing

[0592] Requesting Data

[0593] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the device requests the server to generate a new scenario.

[0594] Acquiring and Applying New Data

[0595] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[0596] Player Notification

[0597] The device will notify the player that a new scenario or quest has been added. The notification will appear in the UI as "New quest added."

[0598] Player behavior data storage

[0599] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0600] User-side processing

[0601] Play

[0602] Users play the game, converse with NPCs, and take on new side story quests.

[0603] Quest Progression

[0604] Users progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[0605] Reporting the results

[0606] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[0607] Specific examples

[0608] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs). Based on this data, it customizes a scenario template for "problems occurring in the village fields" and sends the generated scenario data to the device. The device receives this data and displays new dialogue with the villagers in the game. The user then proceeds with a new quest and solves the problems in the village fields. The results are reported from the device to the server and reflected in the next scenario generation.

[0609] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

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

[0611] Step 1: Initialize the database

[0612] When the server starts, it initializes the database and stores NPC character information and scenario templates. The input data includes basic information about non-player characters and scenario templates. Specifically, the server registers information about villagers, enemy characters, and main characters in the database, and saves scenario templates such as "There is a problem in the village fields." The initialized database is generated as output.

[0613] Step 2: Get Player Data

[0614] The server retrieves player behavior data periodically or upon player request. The input includes the player's past behavior history and current status. The server collects which NPCs the player has spoken to and which quests they have completed. This updates the player's behavior history data. The output is the updated player data.

[0615] Step 3: Generate a new scenario

[0616] The server's scenario generation module generates a new scenario based on the acquired player data. The inputs include the player's behavior data and a template database. Specifically, the server selects an appropriate scenario template and customizes it based on the player's current situation. For example, it can fine-tune the scenario using information the player previously heard about the "cursed village." The output is new, customized scenario data.

[0617] Step 4: Save and send generated data

[0618] The server saves the generated scenario data in a database and sends it to the player's device. The input includes the generated scenario data. In concrete terms, the server saves the scenario data in a database and sends it to the player's device via the network. The output is the updated database and the sent scenario data.

[0619] Step 5: Request the data

[0620] The device sends a data request to the server when the player triggers a specific event. The input includes a specific event, such as the player arriving at a village. The specific operation is that the device detects this event and sends a request to the server to generate a new scenario. The output is a request to the server.

[0621] Step 6: Acquire and apply new data

[0622] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. The input includes the scenario data sent from the server. Specifically, the device receives this data and reflects it on the game screen. For example, it might display new quest information about a problem with the village's fields. The output is the new scenario applied to the player.

[0623] Step 7: Notify players

[0624] The device notifies the player that a new scenario or quest has been added. The input contains new scenario data. The specific behavior is to display a notification on the device's UI saying "A new quest has been added." The output is to notify the player of the new information.

[0625] Step 8: Storing Player Behavior Data

[0626] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server. The input includes the player's behavioral data. Specifically, the device records the player's behavior and periodically uploads it to the server. The output is the behavioral data stored on the server.

[0627] Step 9: Develop the scenario and report the results

[0628] The player progresses through the quest and reports the results to the server via the device. The input includes the player's quest progress data and result data. Specifically, the device sends the quest completion data to the server, which is reflected in the next scenario generation. The output is updated server data and data to be used in the next scenario generation.

[0629] (Application example 1)

[0630] 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."

[0631] Currently, food delivery services face challenges in providing optimal recommendations and promotions to users. Many services make recommendations based on simple rules, which lack personalization based on individual user preferences and circumstances, preventing improvements to the user experience and maximizing sales. It is also difficult to dynamically generate promotions based on seasons and events.

[0632] 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.

[0633] In this invention, the server includes a means for acquiring player behavior data, a means for automatically generating new scenarios, and a means for transmitting the generated scenarios to the player's terminal, which enables the dynamic generation of personalized recommendations and promotions based on the user's order history and current situation.

[0634] "Player behavior data" refers to information including the player's past behavior history and current status in the game.

[0635] "New scenarios" are new events and quests that players experience in the game, automatically generated based on player behavioral data.

[0636] A "terminal" is a device (such as a PC, smartphone, or game console) that a player uses to control the game.

[0637] A "template database" is a data storage system that stores multiple scenario and dialogue templates in advance.

[0638] "Order history" is data that records details of orders placed by a user in the past.

[0639] "Current conditions" are external conditions that change in real time, such as the user's current geographic location, weather information, time of day, etc.

[0640] "Personalized recommendations" are suggestions that are customized based on a user's individual preferences and behavioral history.

[0641] "Promotion" means providing special offers or discounts to encourage the purchase of a particular product or service.

[0642] "Scenario generation means" refers to algorithms and computing resources for automatically generating new scenarios based on player behavior data.

[0643] Overall structure

[0644] The present invention includes a food delivery system that dynamically generates personalized recommendations and promotions based on a user's ordering history and current circumstances.

[0645] Server-side processing

[0646] 1. Initialize the database

[0647] The server initializes a database on startup to store user information, food menus, and promotion templates, including categories for each food item and a history of past promotions. This database uses a database management system such as MySQL or PostgreSQL.

[0648] 2. Obtaining user data

[0649] The server periodically, or upon user request, retrieves the user's order history and current status (e.g., geographic location, weather information). This data may include the user's preferred dishes, the region they live in, the current time zone, etc.

[0650] 3. Generate a new promotion

[0651] The server's scenario generation module creates new promotions based on user data, using a generative AI model (e.g., OpenAI's GPT-4) to customize promotions based on appropriate templates.

[0652] 4. Storage and transmission of generated data

[0653] The server stores the generated promotion data in a database and sends it to the user's device, so that the new promotion is available the next time the user opens the app.

[0654] Terminal side processing

[0655] 1. Requesting Data

[0656] The device sends a data request to the server when the user accesses the app. For example, if the user opens the app during a certain time of day, a request is automatically sent to generate promotions relevant to that time of day.

[0657] 2. Acquire and apply new data

[0658] The device receives the promotion and menu recommendation data sent from the server and applies it to the user. Specifically, new promotions are displayed on the user's screen.

[0659] 3. Notice to Users

[0660] The device will notify the user when new promotions or recommended dishes are added. For example, by using an in-app pop-up notification or push notification to inform the user that "We have a new promotion!"

[0661] User processing

[0662] 1. Use

[0663] A user uses the app to see new recommendations and promotions, for example by tapping on a promotion banner displayed within the app to learn more.

[0664] 2. Use of Promotions

[0665] A user orders food using a new promotion, such as a free garlic bread promotion with any pizza order.

[0666] 3. Reporting the results

[0667] The user's order details are sent to the server and used to generate the next promotion, which allows the user's preferences and behavior to be reflected in the next offer, providing a more personalized experience.

[0668] Examples and prompts

[0669] As a concrete example, if a user has frequently ordered pizza in the past, we can use prompt sentences like the following to feed the generative AI model:

[0670] Example prompt sentence:

[0671] The user's past order history is as follows:

[0672] 1. Pizza Margherita

[0673] 2. Seafood Pizza

[0674] Create a new promotion that your users will be interested in. Generate specific promotion details, descriptions, and applicable conditions.

[0675] Based on this prompt, the Generator AI will generate a promotion like this:

[0676] Promotion details: "For a limited time only! Get a free side dish with any pizza order."

[0677] Description: "Order a Pizza Margherita or Seafood Pizza and get a free side like garlic bread or chocolate cake."

[0678] Conditions apply: "This is a limited time offer. Orders placed by the end of this week are eligible."

[0679] The generated promotions are sent to the user's smartphone and can be notified to the user through the app's notification function. The user can then check the promotions and place an order within the app.

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

[0681] Step 1:

[0682] Initializing the database

[0683] The server initializes the database when the system starts up. Here, user information, food menus, past promotion templates, etc. are registered in a database management system such as MySQL or PostgreSQL. Specifically, SQL queries are used to create tables that store information about users, food, and promotions.

[0684] Input: Database schema information

[0685] Output: initialized database

[0686] Step 2:

[0687] Retrieving User Data

[0688] The server periodically, or upon user request, retrieves the user's order history and current status from the database. The order history includes the dishes previously ordered and the order date and time. The current status includes the geographic location and weather information. Specifically, this information is retrieved from the database using SQL queries.

[0689] Input: User ID, relevant status information

[0690] Output: User's order history, current status

[0691] Step 3:

[0692] Generate a new promotion

[0693] The server's scenario generation module generates new promotions based on the user's order history and current status. A generative AI model (e.g., GPT-4) is used for generation. Specifically, the order history and status information are input to the AI ​​as prompts, and the response from the AI ​​is obtained as a promotion.

[0694] Input: User's order history, current status

[0695] Output: The newly generated promotion

[0696] Step 4:

[0697] Storing and sending generated data

[0698] The server stores the generated promotion data in a database and transmits the data to the user's device by inserting the promotion data into the database using an SQL query and then transmitting it to the device using a REST API or other data communication method.

[0699] Input: The newly generated promotion

[0700] Output: Saved promotion data, Sent promotion data

[0701] Step 5:

[0702] Requesting Data

[0703] When a user accesses an app, the device sends a data request to the server. This is a request to obtain information related to the user's current status. Specifically, it uses an HTTP request to request the necessary data from the server.

[0704] Input: User action

[0705] Output: Data request to the server

[0706] Step 6:

[0707] Acquiring and Applying New Data

[0708] The device receives the promotion and recommended menu data sent from the server and applies it to the user. Specifically, it displays the received data in the app's UI and notifies the user in an appropriate format.

[0709] Input: Promotion data sent from the server

[0710] Output: Display of data on user terminal

[0711] Step 7:

[0712] User Notification

[0713] The device will notify users when new promotions or recommended dishes have been added, using push notifications or in-app pop-ups to inform users of the new information.

[0714] Input: New promotion data

[0715] Output: User notification

[0716] Step 8:

[0717] Reporting the results

[0718] When a user places an order using a new promotion, the result is reported to the server, which sends the order details to the server and stores them in a database for use in generating the next promotion.

[0719] Input: Order details

[0720] Output: Stored order data, reflected in next promotion generation

[0721] 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.

[0722] The system of the present invention is equipped with a process for dynamically generating sub-stories and NPC dialogue based on player behavioral and emotional data in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system provides an environment where writers and engineers can focus on writing major updates and the main story. Furthermore, by combining it with an emotion engine that recognizes user emotions, it is possible to provide content that is more tailored to the player.

[0723] Server-side processing

[0724] 1. Initialize the database

[0725] When the server starts, it initializes the database, storing NPC character information, basic dialogue templates, quest templates, and data for the emotion engine. For example, it registers information about villagers, enemies, and main characters.

[0726] 2. Acquiring player data

[0727] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[0728] 3. Acquiring Emotion Data

[0729] The server's emotion engine collects emotion data from the player's device, which is inferred from the player's facial expressions, tone of voice, and selected options.

[0730] 4. Generate a new scenario

[0731] The server's scenario generation module selects the most suitable scenario template from a template database based on the acquired player's behavioral data and emotional data.

[0732] 5. Customizing the scenario

[0733] The server's scenario generation module customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs with agricultural knowledge and situations in which the player is surprised.

[0734] 6. Storage and transmission of generated data

[0735] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[0736] Terminal side processing

[0737] 1. Requesting Data

[0738] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[0739] 2. Acquire and apply new data

[0740] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[0741] 3. Notice to Players

[0742] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[0743] 4. Acquiring Emotion Data

[0744] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[0745] 5. Storage of Player Behavior Data

[0746] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0747] User processing

[0748] 1. Play

[0749] Users play the game, converse with NPCs, and receive new sub-story quests.

[0750] 2. Quest Progression

[0751] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[0752] 3. Reporting the results

[0753] Once the user completes the quest, the results are reported back to the server via the device.

[0754] In this way, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, it is possible to provide players with more appropriate difficulty levels and content.

[0755] The processing flow will be explained below.

[0756] Step 1:

[0757] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, quest templates, and data for the emotion engine.

[0758] Step 2:

[0759] When the player moves to a new area or triggers a specific event, the device sends a request to the server for the player's behavioral and emotional data.

[0760] Step 3:

[0761] The server receives requests from the device and obtains the player's past behavioral data, current status, and emotional data from the emotion engine. Specifically, it obtains information such as which NPCs the player has spoken to in the past, which quests they have completed, and the player's current emotional state (such as surprise, joy, sadness, etc.).

[0762] Step 4:

[0763] The server's scenario generation module selects the most appropriate scenario template from the template database based on the acquired player data and emotion data. For example, if the player is interested in agriculture, it will select an agriculture-related scenario.

[0764] Step 5:

[0765] The server's scenario generation module customizes the selected template based on the player's behavioral history and emotional data. For example, if the player has the emotion "surprise," it will add a surprise element to the scenario.

[0766] Step 6:

[0767] The server stores the generated scenario data in a database and transmits it to the device, adjusting the difficulty and content according to the player's emotions.

[0768] Step 7:

[0769] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[0770] Step 8:

[0771] The device notifies the player that a new sub-story or quest has been added. The UI displays "A new quest has been added," and also displays a message based on the player's emotion.

[0772] Step 9:

[0773] The device collects emotional data such as the player's facial expressions and voice in real time and sends it to the emotion engine on the server, which continuously monitors the player's current emotional state.

[0774] Step 10:

[0775] Users play the game and experience new scenarios and quests, where they can converse with NPCs and take action to solve problems.

[0776] Step 11:

[0777] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[0778] Step 12:

[0779] When a user completes a quest, the results are reported to the server via the device, including the player's quest progress, choices, and emotional changes.

[0780] Step 13:

[0781] The server receives the player's new behavioral and emotional data and stores it in a database. This data will be used to generate the next scenario.

[0782] Through these steps, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, the system can provide players with more appropriate difficulty levels and content.

[0783] Example 2

[0784] 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."

[0785] In traditional open-world RPGs, it was difficult to generate dynamic scenarios based on the player's actions and emotions, which meant that players would quickly run out of things to do. Additionally, writing major updates and main stories required a significant amount of effort, placing a heavy burden on game developers. Furthermore, it was difficult to provide content that responded to the player's emotions, making it impossible to provide the optimal gaming experience for players.

[0786] 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.

[0787] In this invention, the server includes means for acquiring player behavioral data, means for acquiring player emotional data, means for automatically generating a new scenario based on the player behavioral data and emotional data, means for customizing the new scenario based on the player's behavioral history and current situation, means for transmitting the generated scenario to the player's device, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This makes it possible to provide players with constantly new experiences and create an environment where game developers can focus on the main story and updates.

[0788] "Player behavioral data" refers to the actions and choices a game player takes in the game, and the information obtained as a result of those actions and choices, including locations visited, enemies defeated, items acquired, and quest progress.

[0789] "Player emotional data" refers to data that indicates the emotional state that a player expresses while playing a game. Specifically, it includes data that is estimated from the player's facial expressions and tone of voice.

[0790] A "scenario" is the story or plot of events that unfolds within a game, including the goals the player must achieve and the dialogue they will have with non-player characters (NPCs).

[0791] The "template database" is a database that stores the basic frameworks and templates of various scenarios. An appropriate scenario template is selected from this database, and then customized based on the behavioral and emotional data of individual players.

[0792] "Device" refers to the electronic device used by a player to play a game, including personal computers, smartphones, and game consoles.

[0793] The "emotion engine" is a software module that analyzes the player's emotional data and estimates their emotional state, making it possible to provide the player with optimal scenarios and content.

[0794] In this invention, "means" refers to a series of processes or devices for realizing a specific function. In this case, this refers to "means for acquiring player behavior data" and "means for automatically generating new scenarios."

[0795] The present invention is a system for dynamically generating sub-stories and NPC dialogue based on player behavioral data and emotional data in an open-world RPG.

[0796] Server-side processing

[0797] The server first initializes the database. Here, a database system such as MongoDB or MySQL is used to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. Specifically, information about a character called "Villager A" and profiles of enemy characters are registered.

[0798] Next, the server retrieves the player's behavioral data. This is done periodically or upon the player's request. An API is provided to store the player's behavioral history and current status. The behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[0799] The server's emotion engine receives facial recognition data and voice tone analysis data sent from the player's device using OpenCV or the Google Cloud Speech-to-Text API, and sends the data to the API endpoint "POST / emotion_data."

[0800] Using the acquired behavioral and emotional data, the scenario generation module selects an appropriate scenario template from the template database. For example, it filters the data based on the player data for "recent_quest_type=agriculture" and selects a scenario that matches the "surprised" emotion.

[0801] The selected template is customized based on the player's behavioral history and current situation. For example, a base scenario in which "there is a problem in the village's fields" can be customized based on information from "past conversations the player has had with NPCs with agricultural knowledge" to "a new species of pest has appeared. By talking to the agricultural expert from a previous conversation, a surprising solution will be discovered."

[0802] The generated scenario is saved in the database and sent to the terminal using "POST / new_scenario".

[0803] Terminal side processing

[0804] The device sends a data request to the server when the player triggers a specific event. For example, by issuing a request such as "GET / generate_scenario?event=village_arrival", the device requests the generation of a new scenario.

[0805] The device that receives the new scenario data from the server applies it to the player. Specifically, the device displays the quest information in the game, saying, "There is a problem in the village fields."

[0806] To notify players that a new scenario has been added, the device will notify them with a pop-up notification and a UI change that says "A new quest has been added."

[0807] To capture the player's facial and voice data, the device uses a webcam and microphone and sends this data to the server's emotion engine. Using OpenCV and speech recognition APIs, the data is sent to "POST / emotion_data".

[0808] When a player progresses through a quest or talks with an NPC, their behavioral data is collected on the device and uploaded to the server. This data is sent to the server as "POST / action_data".

[0809] User processing

[0810] The user plays the game, talks to NPCs, and receives new sub-story quests. For example, the user talks to a villager and learns that "there is a problem in the village's fields."

[0811] The user progresses through the quest and takes actions to achieve the specified goal, for example, solving a problem in the fields at the request of a villager.

[0812] When the user completes a quest, they report the result to the server via their device. By pressing the quest end button, the completion status is sent to the server.

[0813] Examples and prompts

[0814] For example, when a player arrives at a village, the device sends a request to the server to "generate a new scenario." The server selects and adjusts the scenario "There is a problem in the village's fields" based on the player's behavioral and emotional data. The scenario is sent to the device and displayed as a new quest on the player's screen.

[0815] An example of a prompt sentence would be, "The player has arrived at the village fields. In the past, he has had a conversation with an NPC who has knowledge of agriculture. The player is now surprised. Please generate the next development." By inputting this into the generation AI model, a scenario and NPC lines can be generated.

[0816] This completes the implementation of the present invention. This system allows players to enjoy a constant stream of new adventures, and allows game developers to focus on major updates and storylines.

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

[0818] Step 1:

[0819] Initializing the database

[0820] The server initializes a database such as MongoDB or MySQL. Specifically, it creates tables to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. For example, it registers basic information about a character called "Villager A" and profiles for enemy characters.

[0821] Input: None

[0822] Output: initialized database, initial data stored

[0823] Specific operation: Executes the SQL statement "INSERT INTO NPCs (name, role, backstory) VALUES ('Villager A', 'farmer', 'He is...')".

[0824] Step 2:

[0825] Retrieving Player Data

[0826] The server retrieves player behavior data periodically or upon player request. An API is provided to store the player's behavior history and current status. Behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[0827] Input: API request (e.g. "GET / player_data?player_id=12345")

[0828] Output: Player behavior data

[0829] Specific operation: The server receives a request to the API endpoint and retrieves data from the database using the corresponding SQL statement.

[0830] Step 3:

[0831] Acquiring emotion data

[0832] The server's emotion engine receives facial expression recognition data and voice tone analysis data sent from the player's device. The data is sent to the API endpoint "POST / emotion_data" using OpenCV and Google Cloud Speech-to-Text API.

[0833] Input: Emotion data (e.g., facial expression recognition data, voice tone analysis data)

[0834] Output: Player emotion data

[0835] Specific operation: The device acquires data using the webcam and microphone and sends an API request to the server.

[0836] Step 4:

[0837] Generating a New Scenario

[0838] The scenario generation module selects the optimal scenario template based on the player's behavioral and emotional data acquired, and filters and selects appropriate templates from the template database.

[0839] Input: Player behavior data, player emotion data

[0840] Output: Selected scenario template

[0841] Specific behavior: Execute a query like "SELECT FROM templates WHERE recent_quest_type='agriculture' AND emotion='surprised'" to select templates.

[0842] Step 5:

[0843] Customizing the Scenario

[0844] The server customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, it customizes a scenario template that says, "There is a problem in the village's fields."

[0845] Input: Scenario template, player behavior history, emotional data

[0846] Output: Customized scenario

[0847] Specific operation: Based on information from past conversations the player had with NPCs with agricultural knowledge, a scenario such as "A new species of pest has appeared in the village fields" is generated.

[0848] Step 6:

[0849] Storing and sending generated data

[0850] The server saves the generated scenario data in a database and sends it to the terminal in the form of "POST / new_scenario".

[0851] Input: Customized scenario

[0852] Output: Data sent to the device, saved scenario data

[0853] Specific operation: Executes the SQL statement "INSERT INTO generated_scenarios (scenario_data) VALUES ('...')" and saves it in the database. Then, sends the scenario data to the terminal.

[0854] Step 7:

[0855] Data request (terminal side)

[0856] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, it issues a request like "GET / generate_scenario?event=village_arrival".

[0857] Input: Player actions (specific events)

[0858] Output: Data request to the server

[0859] Specific operation: Automatically send requests to the server according to the player's event triggers.

[0860] Step 8:

[0861] Acquiring and applying new data (terminal side)

[0862] The terminal receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. Specifically, it receives new quest information such as "There is a problem in the village fields."

[0863] Input: Scenario data from the server

[0864] Output: New scenario displayed in game

[0865] Specific operation: Display the received scenario data in the game and notify the player of new sights.

[0866] Step 9:

[0867] Notification to player (device side)

[0868] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[0869] Input: Scenario data received from the server

[0870] Output: Player notification

[0871] Specific behavior: Notify the player of the existence of a new scenario via a pop-up notification or UI change.

[0872] Step 10:

[0873] Acquiring emotion data (device side)

[0874] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[0875] Input: Player's facial expression data, voice data

[0876] Output: Emotion data, sent to the server

[0877] Specific operation: Emotion data is collected using a webcam or microphone and sent to the server via an API request.

[0878] Step 11:

[0879] Saving player behavior data (device side)

[0880] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0881] Input: Player behavior data

[0882] Output: Upload data to the server

[0883] Specific operation: Sends action data (e.g., quest completion status) to the server using "POST / action_data".

[0884] The above is the specific operation and data flow at each processing step. This series of processes ensures that players always enjoy new adventures and experiences, and allows game developers to focus on the main story and updates.

[0885] (Application example 2)

[0886] 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."

[0887] Conventional open-world RPGs and virtual store systems can only provide users with static scenarios and product recommendations, and lack dynamic experiences based on individual behavioral data and real-time emotional data. This can lead to users gradually feeling stale and losing interest. To solve this problem, a system is needed that utilizes user behavioral and emotional data to provide more personalized, dynamic scenarios and product recommendations.

[0888] The specific processing by the specific 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 means for acquiring player behavior data, means for automatically generating a new scenario based on the player behavior data and emotion data, means for transmitting the generated scenario to the player's device, means for collecting data on the scenario as the player progresses and using it to generate the next scenario, and means for recognizing the user's emotions and dynamically generating specific product suggestions and dialogue from store staff based on those emotions. This makes it possible to constantly provide new experiences and sustain the user's interest.

[0889] "Player behavior data" refers to information regarding the actions, such as various operations, movements, selections, and conversations, that a player performs within a game or virtual store.

[0890] "Emotion data" refers to information about emotions and their changes that are estimated from the player's or user's facial expressions, voice, and behavioral tendencies.

[0891] A "scenario" refers to the quests and story that the player progresses through in the game, or the user's purchasing experience and dialogue in the virtual store.

[0892] A "server" is a set of devices and systems that receive and process data sent by players or users, generate the necessary information and content, and send it to the player's or user's terminal.

[0893] A "terminal" is a computer, smartphone, smart glasses, head-mounted display, or other device used by a player or user.

[0894] "Automatic generation" refers to the process of using pre-set algorithms or AI to generate new scenarios, product suggestions, lines, etc. based on data, without manual operation.

[0895] The "template database" is a database that stores multiple templates that serve as the basis for scenarios, product proposals, and dialogue, and can be selected and customized as needed.

[0896] "Real-time" refers to the time characteristics in which data is processed to respond immediately to the actions and emotions of the player or user.

[0897] The system of the present invention dynamically generates new scenarios and product suggestions based on user behavioral and emotional data in open-world RPGs and virtual stores, providing users with constantly new experiences. This system allows users to enjoy games and shopping without getting bored.

[0898] Server-side processing

[0899] The server includes the following means:

[0900] 1. Initialize the database:

[0901] At startup, the server initializes a database and stores data for NPC character information, scenario templates, product catalogs, and emotion engines, such as registering various product categories and staff speech templates.

[0902] 2. Acquiring Player and User Data:

[0903] The server periodically or upon user request retrieves behavioral data, including past behavior history and current status.

[0904] 3. Acquiring emotion data:

[0905] The server's emotion engine acquires emotion data from the user's device, which is estimated from the user's facial expressions and tone of voice.

[0906] 4. Generate new scenarios and product proposals:

[0907] The server's scenario generation module selects the most suitable template from a template database based on the acquired user behavioral data and emotion data.

[0908] 5. Customization of scenarios and product offers:

[0909] The server's scenario generation module customizes the selected template based on the user's behavioral history and emotional state.

[0910] 6. Storage and transmission of generated data:

[0911] The server stores the generated scenarios and product proposals in a database and transmits them to the user's terminal.

[0912] Terminal side processing

[0913] The terminal includes the following means:

[0914] 1. Request for Data:

[0915] Send a data request to the server when a user triggers a specific action, for example, requesting new product suggestions when the user approaches a specific shelf.

[0916] 2. Acquire and apply new data:

[0917] Receives the latest scenarios and product suggestions sent from the server and applies them to the user, for example, notifying them that "New sneakers have arrived and are available at a special price."

[0918] 3. Notice to Users:

[0919] Notify the user that new scenarios or products have been added. Display "New products have been added" on the UI (user interface).

[0920] 4. Acquiring emotion data:

[0921] A facial recognition camera and microphone are used to capture the user's emotional data and send it to the server.

[0922] 5. Storage of User Behavior Data:

[0923] Data is collected when users purchase products or move around the store and uploaded to a server.

[0924] User processing

[0925] The user follows these steps:

[0926] 1. Shopping Experience:

[0927] A user puts on smart glasses and walks around a virtual store.

[0928] 2. Product browsing and selection:

[0929] Users can browse dynamic product suggestions and select products they are interested in. For example, when a user approaches a particular shelf, they might see a message saying, "We recommend these new sneakers."

[0930] 3. Purchasing decision:

[0931] Select your product and complete the purchase process.

[0932] Hardware and software used

[0933] Hardware: Smart glasses (e.g., Google Glass, Vuzix Blade), facial recognition camera, microphone.

[0934] Software: Emotion recognition algorithms (e.g., OpenCV, Affectiva), scenario generation AI (e.g., GPT-3).

[0935] Prompt Sentence Examples

[0936] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

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

[0938] Step 1:

[0939] The server initializes the database. At startup, the server stores NPC character information, scenario templates, product catalogs, and data for the emotion engine in the database. The input is the initial setting data, and the output is the initialized database.

[0940] Step 2:

[0941] The server acquires user behavioral data. At specific times or in response to a user request, the server acquires the user's past behavioral history, purchase history, and browsing history. The input is a request to acquire user behavioral data, and the output is the behavioral data. Data processing involves reading log files and querying databases.

[0942] Step 3:

[0943] The server acquires the user's emotional data. The server's emotion engine identifies emotions by analyzing facial expression and voice data sent from the user's device. The input is the facial expression and voice data acquired from the device, and the output is the analyzed emotional data. Image processing and voice analysis are performed as data processing.

[0944] Step 4:

[0945] The server generates new scenarios and product proposals. The scenario generation module takes the user's behavioral and emotional data as input and selects the optimal template from the template database. The output is a custom scenario or product proposal based on the selected template. Template selection and customization processing are performed as data calculations.

[0946] Step 5:

[0947] The server customizes the generated scenarios and product proposals. Specific proposals and scenarios are adapted based on the user's behavioral history and emotional state. The input is the selected template, the user's behavioral history, and emotional data, and the output is a customized scenario or product proposal. Conditional branching and text generation are performed within the program.

[0948] Step 6:

[0949] The server stores the generated data and sends it to the terminal. The input is a customized scenario or product proposal, and the output is the stored generated data and the data sent to the terminal. The transmission is performed using a data transmission protocol.

[0950] Step 7:

[0951] The device sends a data request to the server. When the user triggers a specific action, the device sends a request for new data to the server. The input is the user's operation and the output is the data request.

[0952] Step 8:

[0953] The device receives new data and applies it. It receives the latest scenario and product proposal data sent from the server and applies it to the user. The input is data from the server, and the output is the applied scenario or product proposal. After data analysis, it is reflected in the UI.

[0954] Step 9:

[0955] The terminal notifies the user. The addition of a new scenario or product is displayed on the UI. The input is the data received from the server, and the output is a notification to the user. The UI is updated to notify the user.

[0956] Step 10:

[0957] The device acquires emotion data and sends it to the server. The device uses a facial recognition camera and microphone to acquire the user's facial expressions and voice, and sends the emotion data to the server in real time. The input is the acquired emotion data, and the output is the data sent to the server. This includes the processes of collecting and sending emotion data.

[0958] Step 11:

[0959] The device stores user behavior data and sends it to the server. Data is collected when the user purchases products or moves around the store and uploaded to the server. The input is the user behavior data, and the output is the data sent to the server. This includes the data collection and transmission process.

[0960] Prompt Sentence Examples

[0961] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

[0962] 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.

[0963] 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.

[0964] 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.

[0965] [Third embodiment]

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

[0967] 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.

[0968] 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).

[0969] 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.

[0970] 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.

[0971] 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).

[0972] 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. 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.

[0973] 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.

[0974] 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.

[0975] 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.

[0976] 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.

[0977] 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."

[0978] The system of the present invention provides a process for dynamically generating sub-stories and NPC dialogue in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system allows writers and engineers to focus on writing major updates and the main story.

[0979] Server-side processing

[0980] 1. Initialize the database

[0981] When the server starts, it initializes the database and stores NPC character information, basic dialogue templates, and quest templates. For example, it registers information about villagers, enemy characters, and main characters.

[0982] 2. Acquiring player data

[0983] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[0984] 3. Generate a new scenario

[0985] The server's scenario generation module creates new scenarios based on the player's behavioral data. The algorithm selects an appropriate scenario template from a template database and customizes it to fit the player's situation.

[0986] 4. Storage and transmission of generated data

[0987] The server stores the generated scenario data in a database and transmits the data to the player's device.

[0988] Terminal side processing

[0989] 1. Requesting Data

[0990] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[0991] 2. Acquire and apply new data

[0992] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[0993] 3. Notice to Players

[0994] The device will notify the player that a new scenario or quest has been added. For example, it will display "A new quest has been added" on the UI.

[0995] 4. Storage of Player Behavior Data

[0996] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[0997] User processing

[0998] 1. Play

[0999] Users play the game, converse with NPCs, and receive new sub-story quests.

[1000] 2. Quest Progression

[1001] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[1002] 3. Reporting the results

[1003] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[1004] Specific examples

[1005] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs) and customizes a scenario template that reads, "There is a problem in the village's fields." This generated scenario data is sent to the device, and new dialogue with the villager, Irene, is displayed. The user then proceeds with a new quest and solves the problem. The results are reported to the server and reflected in the next scenario generation.

[1006] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

[1007] The processing flow will be explained below.

[1008] Step 1:

[1009] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, and quest templates.

[1010] Step 2:

[1011] The device sends player behavior data requests to the server when the player moves to a new area or triggers certain events. Examples include notifications when the player arrives at a village.

[1012] Step 3:

[1013] The server receives a request from the device and retrieves the player's past behavioral data and current status from the database.

[1014] Step 4:

[1015] The server's scenario generation module selects the most suitable scenario template from the template database based on the acquired player data.

[1016] Step 5:

[1017] The server's scenario generation module customizes the selected template to suit the player's behavioral history and current situation. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs who have agricultural knowledge.

[1018] Step 6:

[1019] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[1020] Step 7:

[1021] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[1022] Step 8:

[1023] The device will notify the player that a new sub-story or quest has been added, displaying "New quest added" on the UI.

[1024] Step 9:

[1025] Users play the game and experience new scenarios and quests, where they can converse with NPCs and progress through quests.

[1026] Step 10:

[1027] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[1028] Step 11:

[1029] When a user completes a quest, the results are reported to the server via the device.

[1030] Step 12:

[1031] The server receives the player's new behavior data and stores it in a database. This data will be used to generate the next scenario.

[1032] Through these steps, the system continues to provide new content to players.

[1033] Example 1

[1034] 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."

[1035] Open-world RPGs require dynamic scenario generation methods that allow players to constantly enjoy new experiences. However, traditional systems rely on static scenarios, which can leave players with nothing to do. Furthermore, writing major updates and main stories places a heavy burden on writers and engineers.

[1036] 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.

[1037] In this invention, the server includes means for initializing a database at the start and storing non-player character information and scenario templates, means for periodically acquiring player action data and checking the current status, means for generating a new scenario based on the acquired player data, means for saving the generated scenario data in the database and transmitting it to the player's terminal, means for the player's terminal to receive the new scenario data and notify the player, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This allows players to always have new experiences in the game, and because scenarios are dynamically updated, it is possible to reduce the burden on writers and engineers.

[1038] A "server" is a computer that provides services to other computers in a network.

[1039] A "database" is a system designed to efficiently manage, store, and retrieve data.

[1040] "Non-player character information" is detailed information about in-game characters that are not controlled by the player.

[1041] A "scenario template" is a template that defines the basic structure of events and quests that occur in the game.

[1042] "Player behavior data" is a record of the actions and choices a player makes in the game.

[1043] "Status" is information that indicates the current state and abilities of a player or character.

[1044] "Scenario generation means" refers to a process or device that generates a new scenario based on player behavior data.

[1045] "Scenario data" is a set of information about the generated scenario.

[1046] A "terminal" is a device (such as a computer or smartphone) that a player uses to play a game.

[1047] A "notification means" is a method or device for notifying players that new scenarios or quests have been added.

[1048] A "collection means" is a method or device for collecting data about the scenario in which the player progresses.

[1049] A "template database" is a database in which scenario templates are stored.

[1050] "Behavior history" is a record of the actions a player has taken in the past.

[1051] MODE FOR CARRYING OUT THE INVENTION

[1052] The system of the present invention provides a process for dynamically generating sub-stories and non-player character (NPC) dialogue in an open-world RPG. This system ensures that players always have something new to experience and never run out of things to do in the game. It also provides an environment where writers and engineers can focus on writing major updates and the main story.

[1053] Server-side processing

[1054] Initializing the database

[1055] When the server starts, it initializes the database and stores NPC character information and scenario templates, including basic information and characteristics of villagers, enemies, and main characters.

[1056] Retrieving Player Data

[1057] The server periodically, or upon the player's request, retrieves player behavior data, including the player's past behavior history and current status, such as which NPCs the player has spoken to and which quests they have completed.

[1058] Generating a New Scenario

[1059] The server's scenario generation module generates new scenarios based on the acquired player data. This process involves choosing an appropriate scenario template from a template database and customizing it to fit the player's current situation. For example, if the player has previously heard about a "cursed village," the server adds that relevant information to the scenario.

[1060] Storing and sending generated data

[1061] The server stores the generated scenario data in a database and transmits the data to the player's device.

[1062] Terminal side processing

[1063] Requesting Data

[1064] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the device requests the server to generate a new scenario.

[1065] Acquiring and Applying New Data

[1066] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[1067] Player Notification

[1068] The device will notify the player that a new scenario or quest has been added. The notification will appear in the UI as "New quest added."

[1069] Player behavior data storage

[1070] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[1071] User-side processing

[1072] Play

[1073] Users play the game, converse with NPCs, and take on new side story quests.

[1074] Quest Progression

[1075] Users progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[1076] Reporting the results

[1077] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[1078] Specific examples

[1079] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs). Based on this data, it customizes a scenario template for "problems occurring in the village fields" and sends the generated scenario data to the device. The device receives this data and displays new dialogue with the villagers in the game. The user then proceeds with a new quest and solves the problems in the village fields. The results are reported from the device to the server and reflected in the next scenario generation.

[1080] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

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

[1082] Step 1: Initialize the database

[1083] When the server starts, it initializes the database and stores NPC character information and scenario templates. The input data includes basic information about non-player characters and scenario templates. Specifically, the server registers information about villagers, enemy characters, and main characters in the database, and saves scenario templates such as "There is a problem in the village fields." The initialized database is generated as output.

[1084] Step 2: Get Player Data

[1085] The server retrieves player behavior data periodically or upon player request. The input includes the player's past behavior history and current status. The server collects which NPCs the player has spoken to and which quests they have completed. This updates the player's behavior history data. The output is the updated player data.

[1086] Step 3: Generate a new scenario

[1087] The server's scenario generation module generates a new scenario based on the acquired player data. The inputs include the player's behavior data and a template database. Specifically, the server selects an appropriate scenario template and customizes it based on the player's current situation. For example, it can fine-tune the scenario using information the player previously heard about the "cursed village." The output is new, customized scenario data.

[1088] Step 4: Save and send generated data

[1089] The server saves the generated scenario data in a database and sends it to the player's device. The input includes the generated scenario data. In concrete terms, the server saves the scenario data in a database and sends it to the player's device via the network. The output is the updated database and the sent scenario data.

[1090] Step 5: Request the data

[1091] The device sends a data request to the server when the player triggers a specific event. The input includes a specific event, such as the player arriving at a village. The specific operation is that the device detects this event and sends a request to the server to generate a new scenario. The output is a request to the server.

[1092] Step 6: Acquire and apply new data

[1093] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. The input includes the scenario data sent from the server. Specifically, the device receives this data and reflects it on the game screen. For example, it might display new quest information about a problem with the village's fields. The output is the new scenario applied to the player.

[1094] Step 7: Notify players

[1095] The device notifies the player that a new scenario or quest has been added. The input contains new scenario data. The specific behavior is to display a notification on the device's UI saying "A new quest has been added." The output is to notify the player of the new information.

[1096] Step 8: Storing Player Behavior Data

[1097] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server. The input includes the player's behavioral data. Specifically, the device records the player's behavior and periodically uploads it to the server. The output is the behavioral data stored on the server.

[1098] Step 9: Develop the scenario and report the results

[1099] The player progresses through the quest and reports the results to the server via the device. The input includes the player's quest progress data and result data. Specifically, the device sends the quest completion data to the server, which is reflected in the next scenario generation. The output is updated server data and data to be used in the next scenario generation.

[1100] (Application example 1)

[1101] 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."

[1102] Currently, food delivery services face challenges in providing optimal recommendations and promotions to users. Many services make recommendations based on simple rules, which lack personalization based on individual user preferences and circumstances, preventing improvements to the user experience and maximizing sales. It is also difficult to dynamically generate promotions based on seasons and events.

[1103] 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.

[1104] In this invention, the server includes a means for acquiring player behavior data, a means for automatically generating new scenarios, and a means for transmitting the generated scenarios to the player's terminal, which enables the dynamic generation of personalized recommendations and promotions based on the user's order history and current situation.

[1105] "Player behavior data" refers to information including the player's past behavior history and current status in the game.

[1106] "New scenarios" are new events and quests that players experience in the game, automatically generated based on player behavioral data.

[1107] A "terminal" is a device (such as a PC, smartphone, or game console) that a player uses to control the game.

[1108] A "template database" is a data storage system that stores multiple scenario and dialogue templates in advance.

[1109] "Order history" is data that records details of orders placed by a user in the past.

[1110] "Current conditions" are external conditions that change in real time, such as the user's current geographic location, weather information, time of day, etc.

[1111] "Personalized recommendations" are suggestions that are customized based on a user's individual preferences and behavioral history.

[1112] "Promotion" means providing special offers or discounts to encourage the purchase of a particular product or service.

[1113] "Scenario generation means" refers to algorithms and computing resources for automatically generating new scenarios based on player behavior data.

[1114] Overall structure

[1115] The present invention includes a food delivery system that dynamically generates personalized recommendations and promotions based on a user's ordering history and current circumstances.

[1116] Server-side processing

[1117] 1. Initialize the database

[1118] The server initializes a database on startup to store user information, food menus, and promotion templates, including categories for each food item and a history of past promotions. This database uses a database management system such as MySQL or PostgreSQL.

[1119] 2. Obtaining user data

[1120] The server periodically, or upon user request, retrieves the user's order history and current status (e.g., geographic location, weather information). This data may include the user's preferred dishes, the region they live in, the current time zone, etc.

[1121] 3. Generate a new promotion

[1122] The server's scenario generation module creates new promotions based on user data, using a generative AI model (e.g., OpenAI's GPT-4) to customize promotions based on appropriate templates.

[1123] 4. Storage and transmission of generated data

[1124] The server stores the generated promotion data in a database and sends it to the user's device, so that the new promotion is available the next time the user opens the app.

[1125] Terminal side processing

[1126] 1. Requesting Data

[1127] The device sends a data request to the server when the user accesses the app. For example, if the user opens the app during a certain time of day, a request is automatically sent to generate promotions relevant to that time of day.

[1128] 2. Acquire and apply new data

[1129] The device receives the promotion and menu recommendation data sent from the server and applies it to the user. Specifically, new promotions are displayed on the user's screen.

[1130] 3. Notice to Users

[1131] The device will notify the user when new promotions or recommended dishes are added. For example, by using an in-app pop-up notification or push notification to inform the user that "We have a new promotion!"

[1132] User processing

[1133] 1. Use

[1134] A user uses the app to see new recommendations and promotions, for example by tapping on a promotion banner displayed within the app to learn more.

[1135] 2. Use of Promotions

[1136] A user orders food using a new promotion, such as a free garlic bread promotion with any pizza order.

[1137] 3. Reporting the results

[1138] The user's order details are sent to the server and used to generate the next promotion, which allows the user's preferences and behavior to be reflected in the next offer, providing a more personalized experience.

[1139] Examples and prompts

[1140] As a concrete example, if a user has frequently ordered pizza in the past, we can use prompt sentences like the following to feed the generative AI model:

[1141] Example prompt sentence:

[1142] The user's past order history is as follows:

[1143] 1. Pizza Margherita

[1144] 2. Seafood Pizza

[1145] Create a new promotion that your users will be interested in. Generate specific promotion details, descriptions, and applicable conditions.

[1146] Based on this prompt, the Generator AI will generate a promotion like this:

[1147] Promotion details: "For a limited time only! Get a free side dish with any pizza order."

[1148] Description: "Order a Pizza Margherita or Seafood Pizza and get a free side like garlic bread or chocolate cake."

[1149] Conditions apply: "This is a limited time offer. Orders placed by the end of this week are eligible."

[1150] The generated promotions are sent to the user's smartphone and can be notified to the user through the app's notification function. The user can then check the promotions and place an order within the app.

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

[1152] Step 1:

[1153] Initializing the database

[1154] The server initializes the database when the system starts up. Here, user information, food menus, past promotion templates, etc. are registered in a database management system such as MySQL or PostgreSQL. Specifically, SQL queries are used to create tables that store information about users, food, and promotions.

[1155] Input: Database schema information

[1156] Output: initialized database

[1157] Step 2:

[1158] Retrieving User Data

[1159] The server periodically, or upon user request, retrieves the user's order history and current status from the database. The order history includes the dishes previously ordered and the order date and time. The current status includes the geographic location and weather information. Specifically, this information is retrieved from the database using SQL queries.

[1160] Input: User ID, relevant status information

[1161] Output: User's order history, current status

[1162] Step 3:

[1163] Generate a new promotion

[1164] The server's scenario generation module generates new promotions based on the user's order history and current status. A generative AI model (e.g., GPT-4) is used for generation. Specifically, the order history and status information are input to the AI ​​as prompts, and the response from the AI ​​is obtained as a promotion.

[1165] Input: User's order history, current status

[1166] Output: The newly generated promotion

[1167] Step 4:

[1168] Storing and sending generated data

[1169] The server stores the generated promotion data in a database and transmits the data to the user's device by inserting the promotion data into the database using an SQL query and then transmitting it to the device using a REST API or other data communication method.

[1170] Input: The newly generated promotion

[1171] Output: Saved promotion data, Sent promotion data

[1172] Step 5:

[1173] Requesting Data

[1174] When a user accesses an app, the device sends a data request to the server. This is a request to obtain information related to the user's current status. Specifically, it uses an HTTP request to request the necessary data from the server.

[1175] Input: User action

[1176] Output: Data request to the server

[1177] Step 6:

[1178] Acquiring and Applying New Data

[1179] The device receives the promotion and recommended menu data sent from the server and applies it to the user. Specifically, it displays the received data in the app's UI and notifies the user in an appropriate format.

[1180] Input: Promotion data sent from the server

[1181] Output: Display of data on user terminal

[1182] Step 7:

[1183] User Notification

[1184] The device will notify users when new promotions or recommended dishes have been added, using push notifications or in-app pop-ups to inform users of the new information.

[1185] Input: New promotion data

[1186] Output: User notification

[1187] Step 8:

[1188] Reporting the results

[1189] When a user places an order using a new promotion, the result is reported to the server, which sends the order details to the server and stores them in a database for use in generating the next promotion.

[1190] Input: Order details

[1191] Output: Stored order data, reflected in next promotion generation

[1192] 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.

[1193] The system of the present invention is equipped with a process for dynamically generating sub-stories and NPC dialogue based on player behavioral and emotional data in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system provides an environment where writers and engineers can focus on writing major updates and the main story. Furthermore, by combining it with an emotion engine that recognizes user emotions, it is possible to provide content that is more tailored to the player.

[1194] Server-side processing

[1195] 1. Initialize the database

[1196] When the server starts, it initializes the database, storing NPC character information, basic dialogue templates, quest templates, and data for the emotion engine. For example, it registers information about villagers, enemies, and main characters.

[1197] 2. Acquiring player data

[1198] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[1199] 3. Acquiring Emotion Data

[1200] The server's emotion engine collects emotion data from the player's device, which is inferred from the player's facial expressions, tone of voice, and selected options.

[1201] 4. Generate a new scenario

[1202] The server's scenario generation module selects the most suitable scenario template from a template database based on the acquired player's behavioral data and emotional data.

[1203] 5. Customizing the scenario

[1204] The server's scenario generation module customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs with agricultural knowledge and situations in which the player is surprised.

[1205] 6. Storage and transmission of generated data

[1206] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[1207] Terminal side processing

[1208] 1. Requesting Data

[1209] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[1210] 2. Acquire and apply new data

[1211] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[1212] 3. Notice to Players

[1213] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[1214] 4. Acquiring Emotion Data

[1215] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[1216] 5. Storage of Player Behavior Data

[1217] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[1218] User processing

[1219] 1. Play

[1220] Users play the game, converse with NPCs, and receive new sub-story quests.

[1221] 2. Quest Progression

[1222] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[1223] 3. Reporting the results

[1224] Once the user completes the quest, the results are reported back to the server via the device.

[1225] In this way, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, it is possible to provide players with more appropriate difficulty levels and content.

[1226] The processing flow will be explained below.

[1227] Step 1:

[1228] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, quest templates, and data for the emotion engine.

[1229] Step 2:

[1230] When the player moves to a new area or triggers a specific event, the device sends a request to the server for the player's behavioral and emotional data.

[1231] Step 3:

[1232] The server receives requests from the device and obtains the player's past behavioral data, current status, and emotional data from the emotion engine. Specifically, it obtains information such as which NPCs the player has spoken to in the past, which quests they have completed, and the player's current emotional state (such as surprise, joy, sadness, etc.).

[1233] Step 4:

[1234] The server's scenario generation module selects the most appropriate scenario template from the template database based on the acquired player data and emotion data. For example, if the player is interested in agriculture, it will select an agriculture-related scenario.

[1235] Step 5:

[1236] The server's scenario generation module customizes the selected template based on the player's behavioral history and emotional data. For example, if the player has the emotion "surprise," it will add a surprise element to the scenario.

[1237] Step 6:

[1238] The server stores the generated scenario data in a database and transmits it to the device, adjusting the difficulty and content according to the player's emotions.

[1239] Step 7:

[1240] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[1241] Step 8:

[1242] The device notifies the player that a new sub-story or quest has been added. The UI displays "A new quest has been added," and also displays a message based on the player's emotion.

[1243] Step 9:

[1244] The device collects emotional data such as the player's facial expressions and voice in real time and sends it to the emotion engine on the server, which continuously monitors the player's current emotional state.

[1245] Step 10:

[1246] Users play the game and experience new scenarios and quests, where they can converse with NPCs and take action to solve problems.

[1247] Step 11:

[1248] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[1249] Step 12:

[1250] When a user completes a quest, the results are reported to the server via the device, including the player's quest progress, choices, and emotional changes.

[1251] Step 13:

[1252] The server receives the player's new behavioral and emotional data and stores it in a database. This data will be used to generate the next scenario.

[1253] Through these steps, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, the system can provide players with more appropriate difficulty levels and content.

[1254] Example 2

[1255] 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."

[1256] In traditional open-world RPGs, it was difficult to generate dynamic scenarios based on the player's actions and emotions, which meant that players would quickly run out of things to do. Additionally, writing major updates and main stories required a significant amount of effort, placing a heavy burden on game developers. Furthermore, it was difficult to provide content that responded to the player's emotions, making it impossible to provide the optimal gaming experience for players.

[1257] 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.

[1258] In this invention, the server includes means for acquiring player behavioral data, means for acquiring player emotional data, means for automatically generating a new scenario based on the player behavioral data and emotional data, means for customizing the new scenario based on the player's behavioral history and current situation, means for transmitting the generated scenario to the player's device, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This makes it possible to provide players with constantly new experiences and create an environment where game developers can focus on the main story and updates.

[1259] "Player behavioral data" refers to the actions and choices a game player takes in the game, and the information obtained as a result of those actions and choices, including locations visited, enemies defeated, items acquired, and quest progress.

[1260] "Player emotional data" refers to data that indicates the emotional state that a player expresses while playing a game. Specifically, it includes data that is estimated from the player's facial expressions and tone of voice.

[1261] A "scenario" is the story or plot of events that unfolds within a game, including the goals the player must achieve and the dialogue they will have with non-player characters (NPCs).

[1262] The "template database" is a database that stores the basic frameworks and templates of various scenarios. An appropriate scenario template is selected from this database, and then customized based on the behavioral and emotional data of individual players.

[1263] "Device" refers to the electronic device used by a player to play a game, including personal computers, smartphones, and game consoles.

[1264] The "emotion engine" is a software module that analyzes the player's emotional data and estimates their emotional state, making it possible to provide the player with optimal scenarios and content.

[1265] In this invention, "means" refers to a series of processes or devices for realizing a specific function. In this case, this refers to "means for acquiring player behavior data" and "means for automatically generating new scenarios."

[1266] The present invention is a system for dynamically generating sub-stories and NPC dialogue based on player behavioral data and emotional data in an open-world RPG.

[1267] Server-side processing

[1268] The server first initializes the database. Here, a database system such as MongoDB or MySQL is used to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. Specifically, information about a character called "Villager A" and profiles of enemy characters are registered.

[1269] Next, the server retrieves the player's behavioral data. This is done periodically or upon the player's request. An API is provided to store the player's behavioral history and current status. The behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[1270] The server's emotion engine receives facial recognition data and voice tone analysis data sent from the player's device using OpenCV or the Google Cloud Speech-to-Text API, and sends the data to the API endpoint "POST / emotion_data."

[1271] Using the acquired behavioral and emotional data, the scenario generation module selects an appropriate scenario template from the template database. For example, it filters the data based on the player data for "recent_quest_type=agriculture" and selects a scenario that matches the "surprised" emotion.

[1272] The selected template is customized based on the player's behavioral history and current situation. For example, a base scenario in which "there is a problem in the village's fields" can be customized based on information from "past conversations the player has had with NPCs with agricultural knowledge" to "a new species of pest has appeared. By talking to the agricultural expert from a previous conversation, a surprising solution will be discovered."

[1273] The generated scenario is saved in the database and sent to the terminal using "POST / new_scenario".

[1274] Terminal side processing

[1275] The device sends a data request to the server when the player triggers a specific event. For example, by issuing a request such as "GET / generate_scenario?event=village_arrival", the device requests the generation of a new scenario.

[1276] The device that receives the new scenario data from the server applies it to the player. Specifically, the device displays the quest information in the game, saying, "There is a problem in the village fields."

[1277] To notify players that a new scenario has been added, the device will notify them with a pop-up notification and a UI change that says "A new quest has been added."

[1278] To capture the player's facial and voice data, the device uses a webcam and microphone and sends this data to the server's emotion engine. Using OpenCV and speech recognition APIs, the data is sent to "POST / emotion_data".

[1279] When a player progresses through a quest or talks with an NPC, their behavioral data is collected on the device and uploaded to the server. This data is sent to the server as "POST / action_data".

[1280] User processing

[1281] The user plays the game, talks to NPCs, and receives new sub-story quests. For example, the user talks to a villager and learns that "there is a problem in the village's fields."

[1282] The user progresses through the quest and takes actions to achieve the specified goal, for example, solving a problem in the fields at the request of a villager.

[1283] When the user completes a quest, they report the result to the server via their device. By pressing the quest end button, the completion status is sent to the server.

[1284] Examples and prompts

[1285] For example, when a player arrives at a village, the device sends a request to the server to "generate a new scenario." The server selects and adjusts the scenario "There is a problem in the village's fields" based on the player's behavioral and emotional data. The scenario is sent to the device and displayed as a new quest on the player's screen.

[1286] An example of a prompt sentence would be, "The player has arrived at the village fields. In the past, he has had a conversation with an NPC who has knowledge of agriculture. The player is now surprised. Please generate the next development." By inputting this into the generation AI model, a scenario and NPC lines can be generated.

[1287] This completes the implementation of the present invention. This system allows players to enjoy a constant stream of new adventures, and allows game developers to focus on major updates and storylines.

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

[1289] Step 1:

[1290] Initializing the database

[1291] The server initializes a database such as MongoDB or MySQL. Specifically, it creates tables to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. For example, it registers basic information about a character called "Villager A" and profiles for enemy characters.

[1292] Input: None

[1293] Output: initialized database, initial data stored

[1294] Specific operation: Executes the SQL statement "INSERT INTO NPCs (name, role, backstory) VALUES ('Villager A', 'farmer', 'He is...')".

[1295] Step 2:

[1296] Retrieving Player Data

[1297] The server retrieves player behavior data periodically or upon player request. An API is provided to store the player's behavior history and current status. Behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[1298] Input: API request (e.g. "GET / player_data?player_id=12345")

[1299] Output: Player behavior data

[1300] Specific operation: The server receives a request to the API endpoint and retrieves data from the database using the corresponding SQL statement.

[1301] Step 3:

[1302] Acquiring emotion data

[1303] The server's emotion engine receives facial expression recognition data and voice tone analysis data sent from the player's device. The data is sent to the API endpoint "POST / emotion_data" using OpenCV and Google Cloud Speech-to-Text API.

[1304] Input: Emotion data (e.g., facial expression recognition data, voice tone analysis data)

[1305] Output: Player emotion data

[1306] Specific operation: The device acquires data using the webcam and microphone and sends an API request to the server.

[1307] Step 4:

[1308] Generating a New Scenario

[1309] The scenario generation module selects the optimal scenario template based on the player's behavioral and emotional data acquired, and filters and selects appropriate templates from the template database.

[1310] Input: Player behavior data, player emotion data

[1311] Output: Selected scenario template

[1312] Specific behavior: Execute a query like "SELECT FROM templates WHERE recent_quest_type='agriculture' AND emotion='surprised'" to select templates.

[1313] Step 5:

[1314] Customizing the Scenario

[1315] The server customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, it customizes a scenario template that says, "There is a problem in the village's fields."

[1316] Input: Scenario template, player behavior history, emotional data

[1317] Output: Customized scenario

[1318] Specific operation: Based on information from past conversations the player had with NPCs with agricultural knowledge, a scenario such as "A new species of pest has appeared in the village fields" is generated.

[1319] Step 6:

[1320] Storing and sending generated data

[1321] The server saves the generated scenario data in a database and sends it to the terminal in the form of "POST / new_scenario".

[1322] Input: Customized scenario

[1323] Output: Data sent to the device, saved scenario data

[1324] Specific operation: Executes the SQL statement "INSERT INTO generated_scenarios (scenario_data) VALUES ('...')" and saves it in the database. Then, sends the scenario data to the terminal.

[1325] Step 7:

[1326] Data request (terminal side)

[1327] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, it issues a request like "GET / generate_scenario?event=village_arrival".

[1328] Input: Player actions (specific events)

[1329] Output: Data request to the server

[1330] Specific operation: Automatically send requests to the server according to the player's event triggers.

[1331] Step 8:

[1332] Acquiring and applying new data (terminal side)

[1333] The terminal receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. Specifically, it receives new quest information such as "There is a problem in the village fields."

[1334] Input: Scenario data from the server

[1335] Output: New scenario displayed in game

[1336] Specific operation: Display the received scenario data in the game and notify the player of new sights.

[1337] Step 9:

[1338] Notification to player (device side)

[1339] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[1340] Input: Scenario data received from the server

[1341] Output: Player notification

[1342] Specific behavior: Notify the player of the existence of a new scenario via a pop-up notification or UI change.

[1343] Step 10:

[1344] Acquiring emotion data (device side)

[1345] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[1346] Input: Player's facial expression data, voice data

[1347] Output: Emotion data, sent to the server

[1348] Specific operation: Emotion data is collected using a webcam or microphone and sent to the server via an API request.

[1349] Step 11:

[1350] Saving player behavior data (device side)

[1351] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[1352] Input: Player behavior data

[1353] Output: Upload data to the server

[1354] Specific operation: Sends action data (e.g., quest completion status) to the server using "POST / action_data".

[1355] The above is the specific operation and data flow at each processing step. This series of processes ensures that players always enjoy new adventures and experiences, and allows game developers to focus on the main story and updates.

[1356] (Application example 2)

[1357] 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."

[1358] Conventional open-world RPGs and virtual store systems can only provide users with static scenarios and product recommendations, and lack dynamic experiences based on individual behavioral data and real-time emotional data. This can lead to users gradually feeling stale and losing interest. To solve this problem, a system is needed that utilizes user behavioral and emotional data to provide more personalized, dynamic scenarios and product recommendations.

[1359] The specific processing by the specific 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 means for acquiring player behavior data, means for automatically generating a new scenario based on the player behavior data and emotion data, means for transmitting the generated scenario to the player's device, means for collecting data on the scenario as the player progresses and using it to generate the next scenario, and means for recognizing the user's emotions and dynamically generating specific product suggestions and dialogue from store staff based on those emotions. This makes it possible to constantly provide new experiences and sustain the user's interest.

[1360] "Player behavior data" refers to information regarding the actions, such as various operations, movements, selections, and conversations, that a player performs within a game or virtual store.

[1361] "Emotion data" refers to information about emotions and their changes that are estimated from the player's or user's facial expressions, voice, and behavioral tendencies.

[1362] A "scenario" refers to the quests and story that the player progresses through in the game, or the user's purchasing experience and dialogue in the virtual store.

[1363] A "server" is a set of devices and systems that receive and process data sent by players or users, generate the necessary information and content, and send it to the player's or user's terminal.

[1364] A "terminal" is a computer, smartphone, smart glasses, head-mounted display, or other device used by a player or user.

[1365] "Automatic generation" refers to the process of using pre-set algorithms or AI to generate new scenarios, product suggestions, lines, etc. based on data, without manual operation.

[1366] The "template database" is a database that stores multiple templates that serve as the basis for scenarios, product proposals, and dialogue, and can be selected and customized as needed.

[1367] "Real-time" refers to the time characteristics in which data is processed to respond immediately to the actions and emotions of the player or user.

[1368] The system of the present invention dynamically generates new scenarios and product suggestions based on user behavioral and emotional data in open-world RPGs and virtual stores, providing users with constantly new experiences. This system allows users to enjoy games and shopping without getting bored.

[1369] Server-side processing

[1370] The server includes the following means:

[1371] 1. Initialize the database:

[1372] At startup, the server initializes a database and stores data for NPC character information, scenario templates, product catalogs, and emotion engines, such as registering various product categories and staff speech templates.

[1373] 2. Acquiring Player and User Data:

[1374] The server periodically or upon user request retrieves behavioral data, including past behavior history and current status.

[1375] 3. Acquiring emotion data:

[1376] The server's emotion engine acquires emotion data from the user's device, which is estimated from the user's facial expressions and tone of voice.

[1377] 4. Generate new scenarios and product proposals:

[1378] The server's scenario generation module selects the most suitable template from a template database based on the acquired user behavioral data and emotion data.

[1379] 5. Customization of scenarios and product offers:

[1380] The server's scenario generation module customizes the selected template based on the user's behavioral history and emotional state.

[1381] 6. Storage and transmission of generated data:

[1382] The server stores the generated scenarios and product proposals in a database and transmits them to the user's terminal.

[1383] Terminal side processing

[1384] The terminal includes the following means:

[1385] 1. Request for Data:

[1386] Send a data request to the server when a user triggers a specific action, for example, requesting new product suggestions when the user approaches a specific shelf.

[1387] 2. Acquire and apply new data:

[1388] Receives the latest scenarios and product suggestions sent from the server and applies them to the user, for example, notifying them that "New sneakers have arrived and are available at a special price."

[1389] 3. Notice to Users:

[1390] Notify the user that new scenarios or products have been added. Display "New products have been added" on the UI (user interface).

[1391] 4. Acquiring emotion data:

[1392] A facial recognition camera and microphone are used to capture the user's emotional data and send it to the server.

[1393] 5. Storage of User Behavior Data:

[1394] Data is collected when users purchase products or move around the store and uploaded to a server.

[1395] User processing

[1396] The user follows these steps:

[1397] 1. Shopping Experience:

[1398] A user puts on smart glasses and walks around a virtual store.

[1399] 2. Product browsing and selection:

[1400] Users can browse dynamic product suggestions and select products they are interested in. For example, when a user approaches a particular shelf, they might see a message saying, "We recommend these new sneakers."

[1401] 3. Purchasing decision:

[1402] Select your product and complete the purchase process.

[1403] Hardware and software used

[1404] Hardware: Smart glasses (e.g., Google Glass, Vuzix Blade), facial recognition camera, microphone.

[1405] Software: Emotion recognition algorithms (e.g., OpenCV, Affectiva), scenario generation AI (e.g., GPT-3).

[1406] Prompt Sentence Examples

[1407] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

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

[1409] Step 1:

[1410] The server initializes the database. At startup, the server stores NPC character information, scenario templates, product catalogs, and data for the emotion engine in the database. The input is the initial setting data, and the output is the initialized database.

[1411] Step 2:

[1412] The server acquires user behavioral data. At specific times or in response to a user request, the server acquires the user's past behavioral history, purchase history, and browsing history. The input is a request to acquire user behavioral data, and the output is the behavioral data. Data processing involves reading log files and querying databases.

[1413] Step 3:

[1414] The server acquires the user's emotional data. The server's emotion engine identifies emotions by analyzing facial expression and voice data sent from the user's device. The input is the facial expression and voice data acquired from the device, and the output is the analyzed emotional data. Image processing and voice analysis are performed as data processing.

[1415] Step 4:

[1416] The server generates new scenarios and product proposals. The scenario generation module takes the user's behavioral and emotional data as input and selects the optimal template from the template database. The output is a custom scenario or product proposal based on the selected template. Template selection and customization processing are performed as data calculations.

[1417] Step 5:

[1418] The server customizes the generated scenarios and product proposals. Specific proposals and scenarios are adapted based on the user's behavioral history and emotional state. The input is the selected template, the user's behavioral history, and emotional data, and the output is a customized scenario or product proposal. Conditional branching and text generation are performed within the program.

[1419] Step 6:

[1420] The server stores the generated data and sends it to the terminal. The input is a customized scenario or product proposal, and the output is the stored generated data and the data sent to the terminal. The transmission is performed using a data transmission protocol.

[1421] Step 7:

[1422] The device sends a data request to the server. When the user triggers a specific action, the device sends a request for new data to the server. The input is the user's operation and the output is the data request.

[1423] Step 8:

[1424] The device receives new data and applies it. It receives the latest scenario and product proposal data sent from the server and applies it to the user. The input is data from the server, and the output is the applied scenario or product proposal. After data analysis, it is reflected in the UI.

[1425] Step 9:

[1426] The terminal notifies the user. The addition of a new scenario or product is displayed on the UI. The input is the data received from the server, and the output is a notification to the user. The UI is updated to notify the user.

[1427] Step 10:

[1428] The device acquires emotion data and sends it to the server. The device uses a facial recognition camera and microphone to acquire the user's facial expressions and voice, and sends the emotion data to the server in real time. The input is the acquired emotion data, and the output is the data sent to the server. This includes the processes of collecting and sending emotion data.

[1429] Step 11:

[1430] The device stores user behavior data and sends it to the server. Data is collected when the user purchases products or moves around the store and uploaded to the server. The input is the user behavior data, and the output is the data sent to the server. This includes the data collection and transmission process.

[1431] Prompt Sentence Examples

[1432] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

[1433] 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.

[1434] 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.

[1435] 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.

[1436] [Fourth embodiment]

[1437] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1438] 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.

[1439] 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).

[1440] 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.

[1441] 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.

[1442] 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).

[1443] 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. 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.

[1444] 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.

[1445] 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.

[1446] 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.

[1447] 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.

[1448] 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.

[1449] 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."

[1450] The system of the present invention provides a process for dynamically generating sub-stories and NPC dialogue in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system allows writers and engineers to focus on writing major updates and the main story.

[1451] Server-side processing

[1452] 1. Initialize the database

[1453] When the server starts, it initializes the database and stores NPC character information, basic dialogue templates, and quest templates. For example, it registers information about villagers, enemy characters, and main characters.

[1454] 2. Acquiring player data

[1455] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[1456] 3. Generate a new scenario

[1457] The server's scenario generation module creates new scenarios based on the player's behavioral data. The algorithm selects an appropriate scenario template from a template database and customizes it to fit the player's situation.

[1458] 4. Storage and transmission of generated data

[1459] The server stores the generated scenario data in a database and transmits the data to the player's device.

[1460] Terminal side processing

[1461] 1. Requesting Data

[1462] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[1463] 2. Acquire and apply new data

[1464] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[1465] 3. Notice to Players

[1466] The device will notify the player that a new scenario or quest has been added. For example, it will display "A new quest has been added" on the UI.

[1467] 4. Storage of Player Behavior Data

[1468] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[1469] User processing

[1470] 1. Play

[1471] Users play the game, converse with NPCs, and receive new sub-story quests.

[1472] 2. Quest Progression

[1473] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[1474] 3. Reporting the results

[1475] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[1476] Specific examples

[1477] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs) and customizes a scenario template that reads, "There is a problem in the village's fields." This generated scenario data is sent to the device, and new dialogue with the villager, Irene, is displayed. The user then proceeds with a new quest and solves the problem. The results are reported to the server and reflected in the next scenario generation.

[1478] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

[1479] The processing flow will be explained below.

[1480] Step 1:

[1481] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, and quest templates.

[1482] Step 2:

[1483] The device sends player behavior data requests to the server when the player moves to a new area or triggers certain events. Examples include notifications when the player arrives at a village.

[1484] Step 3:

[1485] The server receives a request from the device and retrieves the player's past behavioral data and current status from the database.

[1486] Step 4:

[1487] The server's scenario generation module selects the most suitable scenario template from the template database based on the acquired player data.

[1488] Step 5:

[1489] The server's scenario generation module customizes the selected template to suit the player's behavioral history and current situation. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs who have agricultural knowledge.

[1490] Step 6:

[1491] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[1492] Step 7:

[1493] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[1494] Step 8:

[1495] The device will notify the player that a new sub-story or quest has been added, displaying "New quest added" on the UI.

[1496] Step 9:

[1497] Users play the game and experience new scenarios and quests, where they can converse with NPCs and progress through quests.

[1498] Step 10:

[1499] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[1500] Step 11:

[1501] When a user completes a quest, the results are reported to the server via the device.

[1502] Step 12:

[1503] The server receives the player's new behavior data and stores it in a database. This data will be used to generate the next scenario.

[1504] Through these steps, the system continues to provide new content to players.

[1505] Example 1

[1506] 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."

[1507] Open-world RPGs require dynamic scenario generation methods that allow players to constantly enjoy new experiences. However, traditional systems rely on static scenarios, which can leave players with nothing to do. Furthermore, writing major updates and main stories places a heavy burden on writers and engineers.

[1508] 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.

[1509] In this invention, the server includes means for initializing a database at the start and storing non-player character information and scenario templates, means for periodically acquiring player action data and checking the current status, means for generating a new scenario based on the acquired player data, means for saving the generated scenario data in the database and transmitting it to the player's terminal, means for the player's terminal to receive the new scenario data and notify the player, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This allows players to always have new experiences in the game, and because scenarios are dynamically updated, it is possible to reduce the burden on writers and engineers.

[1510] A "server" is a computer that provides services to other computers in a network.

[1511] A "database" is a system designed to efficiently manage, store, and retrieve data.

[1512] "Non-player character information" is detailed information about in-game characters that are not controlled by the player.

[1513] A "scenario template" is a template that defines the basic structure of events and quests that occur in the game.

[1514] "Player behavior data" is a record of the actions and choices a player makes in the game.

[1515] "Status" is information that indicates the current state and abilities of a player or character.

[1516] "Scenario generation means" refers to a process or device that generates a new scenario based on player behavior data.

[1517] "Scenario data" is a set of information about the generated scenario.

[1518] A "terminal" is a device (such as a computer or smartphone) that a player uses to play a game.

[1519] A "notification means" is a method or device for notifying players that new scenarios or quests have been added.

[1520] A "collection means" is a method or device for collecting data about the scenario in which the player progresses.

[1521] A "template database" is a database in which scenario templates are stored.

[1522] "Behavior history" is a record of the actions a player has taken in the past.

[1523] MODE FOR CARRYING OUT THE INVENTION

[1524] The system of the present invention provides a process for dynamically generating sub-stories and non-player character (NPC) dialogue in an open-world RPG. This system ensures that players always have something new to experience and never run out of things to do in the game. It also provides an environment where writers and engineers can focus on writing major updates and the main story.

[1525] Server-side processing

[1526] Initializing the database

[1527] When the server starts, it initializes the database and stores NPC character information and scenario templates, including basic information and characteristics of villagers, enemies, and main characters.

[1528] Retrieving Player Data

[1529] The server periodically, or upon the player's request, retrieves player behavior data, including the player's past behavior history and current status, such as which NPCs the player has spoken to and which quests they have completed.

[1530] Generating a New Scenario

[1531] The server's scenario generation module generates new scenarios based on the acquired player data. This process involves choosing an appropriate scenario template from a template database and customizing it to fit the player's current situation. For example, if the player has previously heard about a "cursed village," the server adds that relevant information to the scenario.

[1532] Storing and sending generated data

[1533] The server stores the generated scenario data in a database and transmits the data to the player's device.

[1534] Terminal side processing

[1535] Requesting Data

[1536] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the device requests the server to generate a new scenario.

[1537] Acquiring and Applying New Data

[1538] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives quest information that there is a problem with the village fields.

[1539] Player Notification

[1540] The device will notify the player that a new scenario or quest has been added. The notification will appear in the UI as "New quest added."

[1541] Player behavior data storage

[1542] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[1543] User-side processing

[1544] Play

[1545] Users play the game, converse with NPCs, and take on new side story quests.

[1546] Quest Progression

[1547] Users progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[1548] Reporting the results

[1549] When a user completes a quest, the results are reported to the server via the device, and this information is used to generate the next scenario.

[1550] Specific examples

[1551] For example, while a player is exploring a village, the server references the player's past behavioral data (history of hearing about the "cursed village" from other NPCs). Based on this data, it customizes a scenario template for "problems occurring in the village fields" and sends the generated scenario data to the device. The device receives this data and displays new dialogue with the villagers in the game. The user then proceeds with a new quest and solves the problems in the village fields. The results are reported from the device to the server and reflected in the next scenario generation.

[1552] In this way, the system continues to dynamically generate new scenarios, providing players with a never-ending experience.

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

[1554] Step 1: Initialize the database

[1555] When the server starts, it initializes the database and stores NPC character information and scenario templates. The input data includes basic information about non-player characters and scenario templates. Specifically, the server registers information about villagers, enemy characters, and main characters in the database, and saves scenario templates such as "There is a problem in the village fields." The initialized database is generated as output.

[1556] Step 2: Get Player Data

[1557] The server retrieves player behavior data periodically or upon player request. The input includes the player's past behavior history and current status. The server collects which NPCs the player has spoken to and which quests they have completed. This updates the player's behavior history data. The output is the updated player data.

[1558] Step 3: Generate a new scenario

[1559] The server's scenario generation module generates a new scenario based on the acquired player data. The inputs include the player's behavior data and a template database. Specifically, the server selects an appropriate scenario template and customizes it based on the player's current situation. For example, it can fine-tune the scenario using information the player previously heard about the "cursed village." The output is new, customized scenario data.

[1560] Step 4: Save and send generated data

[1561] The server saves the generated scenario data in a database and sends it to the player's device. The input includes the generated scenario data. In concrete terms, the server saves the scenario data in a database and sends it to the player's device via the network. The output is the updated database and the sent scenario data.

[1562] Step 5: Request the data

[1563] The device sends a data request to the server when the player triggers a specific event. The input includes a specific event, such as the player arriving at a village. The specific operation is that the device detects this event and sends a request to the server to generate a new scenario. The output is a request to the server.

[1564] Step 6: Acquire and apply new data

[1565] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. The input includes the scenario data sent from the server. Specifically, the device receives this data and reflects it on the game screen. For example, it might display new quest information about a problem with the village's fields. The output is the new scenario applied to the player.

[1566] Step 7: Notify players

[1567] The device notifies the player that a new scenario or quest has been added. The input contains new scenario data. The specific behavior is to display a notification on the device's UI saying "A new quest has been added." The output is to notify the player of the new information.

[1568] Step 8: Storing Player Behavior Data

[1569] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server. The input includes the player's behavioral data. Specifically, the device records the player's behavior and periodically uploads it to the server. The output is the behavioral data stored on the server.

[1570] Step 9: Develop the scenario and report the results

[1571] The player progresses through the quest and reports the results to the server via the device. The input includes the player's quest progress data and result data. Specifically, the device sends the quest completion data to the server, which is reflected in the next scenario generation. The output is updated server data and data to be used in the next scenario generation.

[1572] (Application example 1)

[1573] 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."

[1574] Currently, food delivery services face challenges in providing optimal recommendations and promotions to users. Many services make recommendations based on simple rules, which lack personalization based on individual user preferences and circumstances, preventing improvements to the user experience and maximizing sales. It is also difficult to dynamically generate promotions based on seasons and events.

[1575] 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.

[1576] In this invention, the server includes a means for acquiring player behavior data, a means for automatically generating new scenarios, and a means for transmitting the generated scenarios to the player's terminal, which enables the dynamic generation of personalized recommendations and promotions based on the user's order history and current situation.

[1577] "Player behavior data" refers to information including the player's past behavior history and current status in the game.

[1578] "New scenarios" are new events and quests that players experience in the game, automatically generated based on player behavioral data.

[1579] A "terminal" is a device (such as a PC, smartphone, or game console) that a player uses to control the game.

[1580] A "template database" is a data storage system that stores multiple scenario and dialogue templates in advance.

[1581] "Order history" is data that records details of orders placed by a user in the past.

[1582] "Current conditions" are external conditions that change in real time, such as the user's current geographic location, weather information, time of day, etc.

[1583] "Personalized recommendations" are suggestions that are customized based on a user's individual preferences and behavioral history.

[1584] "Promotion" means providing special offers or discounts to encourage the purchase of a particular product or service.

[1585] "Scenario generation means" refers to algorithms and computing resources for automatically generating new scenarios based on player behavior data.

[1586] Overall structure

[1587] The present invention includes a food delivery system that dynamically generates personalized recommendations and promotions based on a user's ordering history and current circumstances.

[1588] Server-side processing

[1589] 1. Initialize the database

[1590] The server initializes a database on startup to store user information, food menus, and promotion templates, including categories for each food item and a history of past promotions. This database uses a database management system such as MySQL or PostgreSQL.

[1591] 2. Obtaining user data

[1592] The server periodically, or upon user request, retrieves the user's order history and current status (e.g., geographic location, weather information). This data may include the user's preferred dishes, the region they live in, the current time zone, etc.

[1593] 3. Generate a new promotion

[1594] The server's scenario generation module creates new promotions based on user data, using a generative AI model (e.g., OpenAI's GPT-4) to customize promotions based on appropriate templates.

[1595] 4. Storage and transmission of generated data

[1596] The server stores the generated promotion data in a database and sends it to the user's device, so that the new promotion is available the next time the user opens the app.

[1597] Terminal side processing

[1598] 1. Requesting Data

[1599] The device sends a data request to the server when the user accesses the app. For example, if the user opens the app during a certain time of day, a request is automatically sent to generate promotions relevant to that time of day.

[1600] 2. Acquire and apply new data

[1601] The device receives the promotion and menu recommendation data sent from the server and applies it to the user. Specifically, new promotions are displayed on the user's screen.

[1602] 3. Notice to Users

[1603] The device will notify the user when new promotions or recommended dishes are added. For example, by using an in-app pop-up notification or push notification to inform the user that "We have a new promotion!"

[1604] User processing

[1605] 1. Use

[1606] A user uses the app to see new recommendations and promotions, for example by tapping on a promotion banner displayed within the app to learn more.

[1607] 2. Use of Promotions

[1608] A user orders food using a new promotion, such as a free garlic bread promotion with any pizza order.

[1609] 3. Reporting the results

[1610] The user's order details are sent to the server and used to generate the next promotion, which allows the user's preferences and behavior to be reflected in the next offer, providing a more personalized experience.

[1611] Examples and prompts

[1612] As a concrete example, if a user has frequently ordered pizza in the past, we can use prompt sentences like the following to feed the generative AI model:

[1613] Example prompt sentence:

[1614] The user's past order history is as follows:

[1615] 1. Pizza Margherita

[1616] 2. Seafood Pizza

[1617] Create a new promotion that your users will be interested in. Generate specific promotion details, descriptions, and applicable conditions.

[1618] Based on this prompt, the Generator AI will generate a promotion like this:

[1619] Promotion details: "For a limited time only! Get a free side dish with any pizza order."

[1620] Description: "Order a Pizza Margherita or Seafood Pizza and get a free side like garlic bread or chocolate cake."

[1621] Conditions apply: "This is a limited time offer. Orders placed by the end of this week are eligible."

[1622] The generated promotions are sent to the user's smartphone and can be notified to the user through the app's notification function. The user can then check the promotions and place an order within the app.

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

[1624] Step 1:

[1625] Initializing the database

[1626] The server initializes the database when the system starts up. Here, user information, food menus, past promotion templates, etc. are registered in a database management system such as MySQL or PostgreSQL. Specifically, SQL queries are used to create tables that store information about users, food, and promotions.

[1627] Input: Database schema information

[1628] Output: initialized database

[1629] Step 2:

[1630] Retrieving User Data

[1631] The server periodically, or upon user request, retrieves the user's order history and current status from the database. The order history includes the dishes previously ordered and the order date and time. The current status includes the geographic location and weather information. Specifically, this information is retrieved from the database using SQL queries.

[1632] Input: User ID, relevant status information

[1633] Output: User's order history, current status

[1634] Step 3:

[1635] Generate a new promotion

[1636] The server's scenario generation module generates new promotions based on the user's order history and current status. A generative AI model (e.g., GPT-4) is used for generation. Specifically, the order history and status information are input to the AI ​​as prompts, and the response from the AI ​​is obtained as a promotion.

[1637] Input: User's order history, current status

[1638] Output: The newly generated promotion

[1639] Step 4:

[1640] Storing and sending generated data

[1641] The server stores the generated promotion data in a database and transmits the data to the user's device by inserting the promotion data into the database using an SQL query and then transmitting it to the device using a REST API or other data communication method.

[1642] Input: The newly generated promotion

[1643] Output: Saved promotion data, Sent promotion data

[1644] Step 5:

[1645] Requesting Data

[1646] When a user accesses an app, the device sends a data request to the server. This is a request to obtain information related to the user's current status. Specifically, it uses an HTTP request to request the necessary data from the server.

[1647] Input: User action

[1648] Output: Data request to the server

[1649] Step 6:

[1650] Acquiring and Applying New Data

[1651] The device receives the promotion and recommended menu data sent from the server and applies it to the user. Specifically, it displays the received data in the app's UI and notifies the user in an appropriate format.

[1652] Input: Promotion data sent from the server

[1653] Output: Display of data on user terminal

[1654] Step 7:

[1655] User Notification

[1656] The device will notify users when new promotions or recommended dishes have been added, using push notifications or in-app pop-ups to inform users of the new information.

[1657] Input: New promotion data

[1658] Output: User notification

[1659] Step 8:

[1660] Reporting the results

[1661] When a user places an order using a new promotion, the result is reported to the server, which sends the order details to the server and stores them in a database for use in generating the next promotion.

[1662] Input: Order details

[1663] Output: Stored order data, reflected in next promotion generation

[1664] 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.

[1665] The system of the present invention is equipped with a process for dynamically generating sub-stories and NPC dialogue based on player behavioral and emotional data in an open-world RPG. This allows players to constantly enjoy new experiences and never run out of things to do in the game. This system provides an environment where writers and engineers can focus on writing major updates and the main story. Furthermore, by combining it with an emotion engine that recognizes user emotions, it is possible to provide content that is more tailored to the player.

[1666] Server-side processing

[1667] 1. Initialize the database

[1668] When the server starts, it initializes the database, storing NPC character information, basic dialogue templates, quest templates, and data for the emotion engine. For example, it registers information about villagers, enemies, and main characters.

[1669] 2. Acquiring player data

[1670] The server periodically, or upon a player's request, retrieves player behavior data, including the player's past behavior history and current status.

[1671] 3. Acquiring Emotion Data

[1672] The server's emotion engine collects emotion data from the player's device, which is inferred from the player's facial expressions, tone of voice, and selected options.

[1673] 4. Generate a new scenario

[1674] The server's scenario generation module selects the most suitable scenario template from a template database based on the acquired player's behavioral data and emotional data.

[1675] 5. Customizing the scenario

[1676] The server's scenario generation module customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, a scenario in which "there is a problem in the village's fields" can be adjusted based on information such as the player's past conversations with NPCs with agricultural knowledge and situations in which the player is surprised.

[1677] 6. Storage and transmission of generated data

[1678] The server stores the generated scenario data in a database and transmits the scenario data to the terminal.

[1679] Terminal side processing

[1680] 1. Requesting Data

[1681] The terminal sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, the terminal automatically requests the generation of a new scenario.

[1682] 2. Acquire and apply new data

[1683] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[1684] 3. Notice to Players

[1685] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[1686] 4. Acquiring Emotion Data

[1687] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[1688] 5. Storage of Player Behavior Data

[1689] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[1690] User processing

[1691] 1. Play

[1692] Users play the game, converse with NPCs, and receive new sub-story quests.

[1693] 2. Quest Progression

[1694] Users can progress through new quests, take specific actions, and achieve quest goals, such as solving problems in the fields at the request of villagers.

[1695] 3. Reporting the results

[1696] Once the user completes the quest, the results are reported back to the server via the device.

[1697] In this way, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, it is possible to provide players with more appropriate difficulty levels and content.

[1698] The processing flow will be explained below.

[1699] Step 1:

[1700] The server initializes the database when the game starts. It stores NPC character information, dialogue templates, quest templates, and data for the emotion engine.

[1701] Step 2:

[1702] When the player moves to a new area or triggers a specific event, the device sends a request to the server for the player's behavioral and emotional data.

[1703] Step 3:

[1704] The server receives requests from the device and obtains the player's past behavioral data, current status, and emotional data from the emotion engine. Specifically, it obtains information such as which NPCs the player has spoken to in the past, which quests they have completed, and the player's current emotional state (such as surprise, joy, sadness, etc.).

[1705] Step 4:

[1706] The server's scenario generation module selects the most appropriate scenario template from the template database based on the acquired player data and emotion data. For example, if the player is interested in agriculture, it will select an agriculture-related scenario.

[1707] Step 5:

[1708] The server's scenario generation module customizes the selected template based on the player's behavioral history and emotional data. For example, if the player has the emotion "surprise," it will add a surprise element to the scenario.

[1709] Step 6:

[1710] The server stores the generated scenario data in a database and transmits it to the device, adjusting the difficulty and content according to the player's emotions.

[1711] Step 7:

[1712] The device receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. For example, it receives new quest information such as "There is a problem in the village fields."

[1713] Step 8:

[1714] The device notifies the player that a new sub-story or quest has been added. The UI displays "A new quest has been added," and also displays a message based on the player's emotion.

[1715] Step 9:

[1716] The device collects emotional data such as the player's facial expressions and voice in real time and sends it to the emotion engine on the server, which continuously monitors the player's current emotional state.

[1717] Step 10:

[1718] Users play the game and experience new scenarios and quests, where they can converse with NPCs and take action to solve problems.

[1719] Step 11:

[1720] The user progresses through the quest, takes specific actions, and achieves the quest's goal, for example, solving a problem in the fields at the request of a villager.

[1721] Step 12:

[1722] When a user completes a quest, the results are reported to the server via the device, including the player's quest progress, choices, and emotional changes.

[1723] Step 13:

[1724] The server receives the player's new behavioral and emotional data and stores it in a database. This data will be used to generate the next scenario.

[1725] Through these steps, the system dynamically generates new scenarios based on the player's behavioral and emotional data, allowing the player to constantly enjoy new experiences. In addition, by combining the emotion engine, the system can provide players with more appropriate difficulty levels and content.

[1726] Example 2

[1727] 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."

[1728] In traditional open-world RPGs, it was difficult to generate dynamic scenarios based on the player's actions and emotions, which meant that players would quickly run out of things to do. Additionally, writing major updates and main stories required a significant amount of effort, placing a heavy burden on game developers. Furthermore, it was difficult to provide content that responded to the player's emotions, making it impossible to provide the optimal gaming experience for players.

[1729] 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.

[1730] In this invention, the server includes means for acquiring player behavioral data, means for acquiring player emotional data, means for automatically generating a new scenario based on the player behavioral data and emotional data, means for customizing the new scenario based on the player's behavioral history and current situation, means for transmitting the generated scenario to the player's device, and means for collecting data on the scenario as the player progresses and using it to generate the next scenario. This makes it possible to provide players with constantly new experiences and create an environment where game developers can focus on the main story and updates.

[1731] "Player behavioral data" refers to the actions and choices a game player takes in the game, and the information obtained as a result of those actions and choices, including locations visited, enemies defeated, items acquired, and quest progress.

[1732] "Player emotional data" refers to data that indicates the emotional state that a player expresses while playing a game. Specifically, it includes data that is estimated from the player's facial expressions and tone of voice.

[1733] A "scenario" is the story or plot of events that unfolds within a game, including the goals the player must achieve and the dialogue they will have with non-player characters (NPCs).

[1734] The "template database" is a database that stores the basic frameworks and templates of various scenarios. An appropriate scenario template is selected from this database, and then customized based on the behavioral and emotional data of individual players.

[1735] "Device" refers to the electronic device used by a player to play a game, including personal computers, smartphones, and game consoles.

[1736] The "emotion engine" is a software module that analyzes the player's emotional data and estimates their emotional state, making it possible to provide the player with optimal scenarios and content.

[1737] In this invention, "means" refers to a series of processes or devices for realizing a specific function. In this case, this refers to "means for acquiring player behavior data" and "means for automatically generating new scenarios."

[1738] The present invention is a system for dynamically generating sub-stories and NPC dialogue based on player behavioral data and emotional data in an open-world RPG.

[1739] Server-side processing

[1740] The server first initializes the database. Here, a database system such as MongoDB or MySQL is used to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. Specifically, information about a character called "Villager A" and profiles of enemy characters are registered.

[1741] Next, the server retrieves the player's behavioral data. This is done periodically or upon the player's request. An API is provided to store the player's behavioral history and current status. The behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[1742] The server's emotion engine receives facial recognition data and voice tone analysis data sent from the player's device using OpenCV or the Google Cloud Speech-to-Text API, and sends the data to the API endpoint "POST / emotion_data."

[1743] Using the acquired behavioral and emotional data, the scenario generation module selects an appropriate scenario template from the template database. For example, it filters the data based on the player data for "recent_quest_type=agriculture" and selects a scenario that matches the "surprised" emotion.

[1744] The selected template is customized based on the player's behavioral history and current situation. For example, a base scenario in which "there is a problem in the village's fields" can be customized based on information from "past conversations the player has had with NPCs with agricultural knowledge" to "a new species of pest has appeared. By talking to the agricultural expert from a previous conversation, a surprising solution will be discovered."

[1745] The generated scenario is saved in the database and sent to the terminal using "POST / new_scenario".

[1746] Terminal side processing

[1747] The device sends a data request to the server when the player triggers a specific event. For example, by issuing a request such as "GET / generate_scenario?event=village_arrival", the device requests the generation of a new scenario.

[1748] The device that receives the new scenario data from the server applies it to the player. Specifically, the device displays the quest information in the game, saying, "There is a problem in the village fields."

[1749] To notify players that a new scenario has been added, the device will notify them with a pop-up notification and a UI change that says "A new quest has been added."

[1750] To capture the player's facial and voice data, the device uses a webcam and microphone and sends this data to the server's emotion engine. Using OpenCV and speech recognition APIs, the data is sent to "POST / emotion_data".

[1751] When a player progresses through a quest or talks with an NPC, their behavioral data is collected on the device and uploaded to the server. This data is sent to the server as "POST / action_data".

[1752] User processing

[1753] The user plays the game, talks to NPCs, and receives new sub-story quests. For example, the user talks to a villager and learns that "there is a problem in the village's fields."

[1754] The user progresses through the quest and takes actions to achieve the specified goal, for example, solving a problem in the fields at the request of a villager.

[1755] When the user completes a quest, they report the result to the server via their device. By pressing the quest end button, the completion status is sent to the server.

[1756] Examples and prompts

[1757] For example, when a player arrives at a village, the device sends a request to the server to "generate a new scenario." The server selects and adjusts the scenario "There is a problem in the village's fields" based on the player's behavioral and emotional data. The scenario is sent to the device and displayed as a new quest on the player's screen.

[1758] An example of a prompt sentence would be, "The player has arrived at the village fields. In the past, he has had a conversation with an NPC who has knowledge of agriculture. The player is now surprised. Please generate the next development." By inputting this into the generation AI model, a scenario and NPC lines can be generated.

[1759] This completes the implementation of the present invention. This system allows players to enjoy a constant stream of new adventures, and allows game developers to focus on major updates and storylines.

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

[1761] Step 1:

[1762] Initializing the database

[1763] The server initializes a database such as MongoDB or MySQL. Specifically, it creates tables to store NPC character information, dialogue templates, quest templates, and data for the emotion engine. For example, it registers basic information about a character called "Villager A" and profiles for enemy characters.

[1764] Input: None

[1765] Output: initialized database, initial data stored

[1766] Specific operation: Executes the SQL statement "INSERT INTO NPCs (name, role, backstory) VALUES ('Villager A', 'farmer', 'He is...')".

[1767] Step 2:

[1768] Retrieving Player Data

[1769] The server retrieves player behavior data periodically or upon player request. An API is provided to store the player's behavior history and current status. Behavioral data is retrieved from the database based on a request such as "GET / player_data?player_id=12345".

[1770] Input: API request (e.g. "GET / player_data?player_id=12345")

[1771] Output: Player behavior data

[1772] Specific operation: The server receives a request to the API endpoint and retrieves data from the database using the corresponding SQL statement.

[1773] Step 3:

[1774] Acquiring emotion data

[1775] The server's emotion engine receives facial expression recognition data and voice tone analysis data sent from the player's device. The data is sent to the API endpoint "POST / emotion_data" using OpenCV and Google Cloud Speech-to-Text API.

[1776] Input: Emotion data (e.g., facial expression recognition data, voice tone analysis data)

[1777] Output: Player emotion data

[1778] Specific operation: The device acquires data using the webcam and microphone and sends an API request to the server.

[1779] Step 4:

[1780] Generating a New Scenario

[1781] The scenario generation module selects the optimal scenario template based on the player's behavioral and emotional data acquired, and filters and selects appropriate templates from the template database.

[1782] Input: Player behavior data, player emotion data

[1783] Output: Selected scenario template

[1784] Specific behavior: Execute a query like "SELECT FROM templates WHERE recent_quest_type='agriculture' AND emotion='surprised'" to select templates.

[1785] Step 5:

[1786] Customizing the Scenario

[1787] The server customizes the selected template based on the player's behavioral history, current situation, and emotional data. For example, it customizes a scenario template that says, "There is a problem in the village's fields."

[1788] Input: Scenario template, player behavior history, emotional data

[1789] Output: Customized scenario

[1790] Specific operation: Based on information from past conversations the player had with NPCs with agricultural knowledge, a scenario such as "A new species of pest has appeared in the village fields" is generated.

[1791] Step 6:

[1792] Storing and sending generated data

[1793] The server saves the generated scenario data in a database and sends it to the terminal in the form of "POST / new_scenario".

[1794] Input: Customized scenario

[1795] Output: Data sent to the device, saved scenario data

[1796] Specific operation: Executes the SQL statement "INSERT INTO generated_scenarios (scenario_data) VALUES ('...')" and saves it in the database. Then, sends the scenario data to the terminal.

[1797] Step 7:

[1798] Data request (terminal side)

[1799] The device sends a data request to the server when the player triggers a specific event. For example, when the player arrives at a village, it issues a request like "GET / generate_scenario?event=village_arrival".

[1800] Input: Player actions (specific events)

[1801] Output: Data request to the server

[1802] Specific operation: Automatically send requests to the server according to the player's event triggers.

[1803] Step 8:

[1804] Acquiring and applying new data (terminal side)

[1805] The terminal receives the latest scenario and NPC dialogue data sent from the server and applies it to the player. Specifically, it receives new quest information such as "There is a problem in the village fields."

[1806] Input: Scenario data from the server

[1807] Output: New scenario displayed in game

[1808] Specific operation: Display the received scenario data in the game and notify the player of new sights.

[1809] Step 9:

[1810] Notification to player (device side)

[1811] The device will notify the player that a new scenario or quest has been added. The UI will display "New quest has been added."

[1812] Input: Scenario data received from the server

[1813] Output: Player notification

[1814] Specific behavior: Notify the player of the existence of a new scenario via a pop-up notification or UI change.

[1815] Step 10:

[1816] Acquiring emotion data (device side)

[1817] The device acquires emotional data such as the player's facial expressions and voice, and sends it to the server's emotion engine.

[1818] Input: Player's facial expression data, voice data

[1819] Output: Emotion data, sent to the server

[1820] Specific operation: Emotion data is collected using a webcam or microphone and sent to the server via an API request.

[1821] Step 11:

[1822] Saving player behavior data (device side)

[1823] The device collects data as the player progresses through quests and talks with NPCs, and uploads it to the server.

[1824] Input: Player behavior data

[1825] Output: Upload data to the server

[1826] Specific operation: Sends action data (e.g., quest completion status) to the server using "POST / action_data".

[1827] The above is the specific operation and data flow at each processing step. This series of processes ensures that players always enjoy new adventures and experiences, and allows game developers to focus on the main story and updates.

[1828] (Application example 2)

[1829] 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."

[1830] Conventional open-world RPGs and virtual store systems can only provide users with static scenarios and product recommendations, and lack dynamic experiences based on individual behavioral data and real-time emotional data. This can lead to users gradually feeling stale and losing interest. To solve this problem, a system is needed that utilizes user behavioral and emotional data to provide more personalized, dynamic scenarios and product recommendations.

[1831] The specific processing by the specific 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 means for acquiring player behavior data, means for automatically generating a new scenario based on the player behavior data and emotion data, means for transmitting the generated scenario to the player's device, means for collecting data on the scenario as the player progresses and using it to generate the next scenario, and means for recognizing the user's emotions and dynamically generating specific product suggestions and dialogue from store staff based on those emotions. This makes it possible to constantly provide new experiences and sustain the user's interest.

[1832] "Player behavior data" refers to information regarding the actions, such as various operations, movements, selections, and conversations, that a player performs within a game or virtual store.

[1833] "Emotion data" refers to information about emotions and their changes that are estimated from the player's or user's facial expressions, voice, and behavioral tendencies.

[1834] A "scenario" refers to the quests and story that the player progresses through in the game, or the user's purchasing experience and dialogue in the virtual store.

[1835] A "server" is a set of devices and systems that receive and process data sent by players or users, generate the necessary information and content, and send it to the player's or user's terminal.

[1836] A "terminal" is a computer, smartphone, smart glasses, head-mounted display, or other device used by a player or user.

[1837] "Automatic generation" refers to the process of using pre-set algorithms or AI to generate new scenarios, product suggestions, lines, etc. based on data, without manual operation.

[1838] The "template database" is a database that stores multiple templates that serve as the basis for scenarios, product proposals, and dialogue, and can be selected and customized as needed.

[1839] "Real-time" refers to the time characteristics in which data is processed to respond immediately to the actions and emotions of the player or user.

[1840] The system of the present invention dynamically generates new scenarios and product suggestions based on user behavioral and emotional data in open-world RPGs and virtual stores, providing users with constantly new experiences. This system allows users to enjoy games and shopping without getting bored.

[1841] Server-side processing

[1842] The server includes the following means:

[1843] 1. Initialize the database:

[1844] At startup, the server initializes a database and stores data for NPC character information, scenario templates, product catalogs, and emotion engines, such as registering various product categories and staff speech templates.

[1845] 2. Acquiring Player and User Data:

[1846] The server periodically or upon user request retrieves behavioral data, including past behavior history and current status.

[1847] 3. Acquiring emotion data:

[1848] The server's emotion engine acquires emotion data from the user's device, which is estimated from the user's facial expressions and tone of voice.

[1849] 4. Generate new scenarios and product proposals:

[1850] The server's scenario generation module selects the most suitable template from a template database based on the acquired user behavioral data and emotion data.

[1851] 5. Customization of scenarios and product offers:

[1852] The server's scenario generation module customizes the selected template based on the user's behavioral history and emotional state.

[1853] 6. Storage and transmission of generated data:

[1854] The server stores the generated scenarios and product proposals in a database and transmits them to the user's terminal.

[1855] Terminal side processing

[1856] The terminal includes the following means:

[1857] 1. Request for Data:

[1858] Send a data request to the server when a user triggers a specific action, for example, requesting new product suggestions when the user approaches a specific shelf.

[1859] 2. Acquire and apply new data:

[1860] Receives the latest scenarios and product suggestions sent from the server and applies them to the user, for example, notifying them that "New sneakers have arrived and are available at a special price."

[1861] 3. Notice to Users:

[1862] Notify the user that new scenarios or products have been added. Display "New products have been added" on the UI (user interface).

[1863] 4. Acquiring emotion data:

[1864] A facial recognition camera and microphone are used to capture the user's emotional data and send it to the server.

[1865] 5. Storage of User Behavior Data:

[1866] Data is collected when users purchase products or move around the store and uploaded to a server.

[1867] User processing

[1868] The user follows these steps:

[1869] 1. Shopping Experience:

[1870] A user puts on smart glasses and walks around a virtual store.

[1871] 2. Product browsing and selection:

[1872] Users can browse dynamic product suggestions and select products they are interested in. For example, when a user approaches a particular shelf, they might see a message saying, "We recommend these new sneakers."

[1873] 3. Purchasing decision:

[1874] Select your product and complete the purchase process.

[1875] Hardware and software used

[1876] Hardware: Smart glasses (e.g., Google Glass, Vuzix Blade), facial recognition camera, microphone.

[1877] Software: Emotion recognition algorithms (e.g., OpenCV, Affectiva), scenario generation AI (e.g., GPT-3).

[1878] Prompt Sentence Examples

[1879] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

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

[1881] Step 1:

[1882] The server initializes the database. At startup, the server stores NPC character information, scenario templates, product catalogs, and data for the emotion engine in the database. The input is the initial setting data, and the output is the initialized database.

[1883] Step 2:

[1884] The server acquires user behavioral data. At specific times or in response to a user request, the server acquires the user's past behavioral history, purchase history, and browsing history. The input is a request to acquire user behavioral data, and the output is the behavioral data. Data processing involves reading log files and querying databases.

[1885] Step 3:

[1886] The server acquires the user's emotional data. The server's emotion engine identifies emotions by analyzing facial expression and voice data sent from the user's device. The input is the facial expression and voice data acquired from the device, and the output is the analyzed emotional data. Image processing and voice analysis are performed as data processing.

[1887] Step 4:

[1888] The server generates new scenarios and product proposals. The scenario generation module takes the user's behavioral and emotional data as input and selects the optimal template from the template database. The output is a custom scenario or product proposal based on the selected template. Template selection and customization processing are performed as data calculations.

[1889] Step 5:

[1890] The server customizes the generated scenarios and product proposals. Specific proposals and scenarios are adapted based on the user's behavioral history and emotional state. The input is the selected template, the user's behavioral history, and emotional data, and the output is a customized scenario or product proposal. Conditional branching and text generation are performed within the program.

[1891] Step 6:

[1892] The server stores the generated data and sends it to the terminal. The input is a customized scenario or product proposal, and the output is the stored generated data and the data sent to the terminal. The transmission is performed using a data transmission protocol.

[1893] Step 7:

[1894] The device sends a data request to the server. When the user triggers a specific action, the device sends a request for new data to the server. The input is the user's operation and the output is the data request.

[1895] Step 8:

[1896] The device receives new data and applies it. It receives the latest scenario and product proposal data sent from the server and applies it to the user. The input is data from the server, and the output is the applied scenario or product proposal. After data analysis, it is reflected in the UI.

[1897] Step 9:

[1898] The terminal notifies the user. The addition of a new scenario or product is displayed on the UI. The input is the data received from the server, and the output is a notification to the user. The UI is updated to notify the user.

[1899] Step 10:

[1900] The device acquires emotion data and sends it to the server. The device uses a facial recognition camera and microphone to acquire the user's facial expressions and voice, and sends the emotion data to the server in real time. The input is the acquired emotion data, and the output is the data sent to the server. This includes the processes of collecting and sending emotion data.

[1901] Step 11:

[1902] The device stores user behavior data and sends it to the server. Data is collected when the user purchases products or moves around the store and uploaded to the server. The input is the user behavior data, and the output is the data sent to the server. This includes the data collection and transmission process.

[1903] Prompt Sentence Examples

[1904] "When the user's face is smiling and their voice indicates happiness, generate prompts that suggest new products or personalized promotional information."

[1905] 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.

[1906] 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.

[1907] 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.

[1908] 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.

[1909] 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 induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1910] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1911] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1912] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1913] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1914] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1915] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1916] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1917] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1918] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1919] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1920] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1921] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1922] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1923] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1924] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1925] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1926] The following is further disclosed regarding the above embodiment.

[1927] (Claim 1)

[1928] A means for acquiring player behavior data;

[1929] means for automatically generating a new scenario based on the player's behavior data;

[1930] A means for transmitting the generated scenario to a player's device;

[1931] A means to collect data on the scenario the player progresses through and use it to generate the next scenario,

[1932] A system including:

[1933] (Claim 2)

[1934] 2. The system according to claim 1, wherein the scenario generating means includes a process of selecting an appropriate template from a template database and customizing it based on the player's behavior history and current situation.

[1935] (Claim 3)

[1936] 2. The system according to claim 1, wherein the player's terminal includes means for receiving new scenario data and notifying the player thereof.

[1937] "Example 1"

[1938] (Claim 1)

[1939] A means for the server to initialize a database at startup and store non-player character information and scenario templates;

[1940] A means to periodically obtain player behavior data and check their current status,

[1941] A means for generating new scenarios based on acquired player data;

[1942] A means for storing the generated scenario data in a database and transmitting it to the player's device;

[1943] A means for the player's device to receive new scenario data and notify the player;

[1944] A means to collect data on the scenario the player progresses through and use it to generate the next scenario,

[1945] A system including:

[1946] (Claim 2)

[1947] 2. The system according to claim 1, wherein the scenario generating means includes a process of selecting an appropriate template from a template database and customizing it based on the player's behavior history and current situation.

[1948] (Claim 3)

[1949] 2. The system according to claim 1, wherein the player's terminal includes means for receiving new scenario data and notifying the player thereof.

[1950] "Application Example 1"

[1951] (Claim 1)

[1952] A means for acquiring player behavior data;

[1953] means for automatically generating a new scenario based on the player's behavior data;

[1954] A means for transmitting the generated scenario to a player's device;

[1955] A means to collect data on the scenario the player progresses through and use it to generate the next scenario,

[1956] A way to dynamically generate personalized recommendations and promotions based on a user's order history and current situation; and

[1957] A system including:

[1958] (Claim 2)

[1959] 2. The system according to claim 1, wherein the scenario generating means includes a process of selecting an appropriate template from a template database and customizing it based on the player's behavior history and current situation.

[1960] (Claim 3)

[1961] 2. The system according to claim 1, wherein the player's terminal includes means for receiving new scenario data and notifying the player thereof.

[1962] "Example 2: Combining Emotion Engines"

[1963] (Claim 1)

[1964] A means for acquiring player behavior data;

[1965] A means for acquiring player emotional data;

[1966] means for automatically generating a new scenario based on the player's behavioral data and emotional data;

[1967] a means for customizing the new scenario based on the player's action history and current situation;

[1968] A means for transmitting the generated scenario to a player's device;

[1969] A means to collect data on the scenario the player progresses through and use it to generate the next scenario,

[1970] A system including:

[1971] (Claim 2)

[1972] 2. The system according to claim 1, wherein the scenario generating means includes a process of selecting an appropriate template from a template database and customizing it based on the player's behavior history, emotional data, and current situation.

[1973] (Claim 3)

[1974] 2. The system according to claim 1, wherein the player's terminal includes means for receiving new scenario data and notifying the player thereof.

[1975] "Application example 2 when combining emotion engines"

[1976] (Claim 1)

[1977] A means for acquiring player behavior data;

[1978] means for automatically generating a new scenario based on the player's behavioral data and emotional data;

[1979] A means for transmitting the generated scenario to a player's device;

[1980] A means to collect data on the scenario the player progresses through and use it to generate the next scenario,

[1981] A means for recognizing the user's emotions and dynamically generating specific product suggestions and store staff dialogue based on those emotions;

[1982] A system including:

[1983] (Claim 2)

[1984] 2. The system according to claim 1, wherein the scenario generating means includes a process of selecting an appropriate template from a template database and customizing it based on the player's behavior history, current situation, and emotional data.

[1985] (Claim 3)

[1986] 2. The system of claim 1, wherein the player's terminal includes means for receiving new scenario data and specific product offers and notifying the player thereof. [Explanation of symbols]

[1987] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. A means for acquiring player behavior data; means for automatically generating a new scenario based on the player's behavior data; A means for transmitting the generated scenario to a player's device; A means to collect data on the scenario the player progresses through and use it to generate the next scenario, A system including:

2. 2. The system according to claim 1, wherein the scenario generating means includes a process for selecting an appropriate template from a template database and customizing it based on the player's action history and current situation.

3. 2. The system according to claim 1, wherein the player's terminal includes means for receiving new scenario data and notifying the player thereof.

Images