Character simulation method and software system and machine using method

Abstract

Embodiments of the present application disclose a character simulation method and a software system or machine using the method. The method comprises: a first software system receives, by means of an information channel, at least one piece of associated information from a character in a second software system, wherein the first software system and the second software system are mutually orthogonal systems, the first software system is executed on a first machine, the second software system is executed on a second machine, and the first machine and / or the first software system provide a human-machine interface; and the first software system drives, on the basis of the at least one piece of associated information, some of components in the human-machine interface to make at least one behavior reaction, wherein the at least one behavior reaction maps at least one simulation result of the character and / or another character by driving at least one structure and / or at least one action of the some of the components, and / or the first software system transmits at least another piece of associated information to the second software system on the basis of the at least one piece of associated information to drive at least another behavior reaction of the character and / or the another character.

Description

A method for role simulation and a software system and machine for applying the method. Technical Field

[0001] This application relates to the fields of computer data processing and artificial intelligence technology, specifically to virtual character behavior simulation and human-computer interaction technology, and more specifically to a method for character simulation and a software system and machine that applies this method. Background Technology

[0002] The research and development of intelligent robots has been ongoing for decades. In recent years, due to advancements in AI technology, intelligent devices that mimic animals have matured and entered markets such as homes, businesses, and even governments; among them, the Sony AIBO robot dog is a major player in the home market. In addition to lifelike robots, other intelligent assistants are provided as apps or services on mobile phones or smart speakers (such as Apple Siri and Google Assistant), making these assistants function like real-life helpers.

[0003] In this article, products including intelligent robots, robot dogs, or any device equipped with an intelligent assistant (such as mobile phones or laptops) can all be referred to as "intelligent devices".

[0004] In general, a smart device is a computing device that combines a hardware system and a software system. Based on a role model, a smart device models a role to serve the user through its human-computer interface, which consists of a mechanical style, hardware input / output interfaces, software input / output interfaces, and / or graphical user interface.

[0005] The character's physical characteristics can be simulated using visible structural design, hardware input / output interface design, software input / output interface design, and / or graphical user interface design; the character's behavioral characteristics are generally simulated by its software system using a predefined processing program; the implementation of these behavioral characteristics can be accomplished through program writing, neural network learning and training, rule base construction, and / or system parameter settings.

[0006] The simulated behavioral patterns, achieved through programming, neural network learning and training, rule base construction, and / or system parameter settings, determine the character's behavioral response to external scene events and / or external scene states within the smart device.

[0007] First, the software system receives external scene events and / or scene states through the input / output devices of its smart devices (e.g., different physical sensors or network signal connectors). For example, it obtains sounds from the real environment through a microphone, images from the real environment through a camera, or connects to other networked devices (e.g., game consoles, IoT sensors) through network signal connectors (e.g., Bluetooth, infrared, WiFi connectors). It then receives scene events and / or scene states from another software system (e.g., 2D / 3D games, temperature detection programs), etc.

[0008] Next, upon receiving external scene events and / or scene states, the software system determines the appropriate behavioral response based on the received scene events or scene states, and converts it into at least one control request. Then, based on the at least one control request, it drives a structural change and / or the execution of an action in the human-machine interface of the associated smart device, thus manifesting these behavioral responses and simulating the character on the associated smart device. The implementation method of determining the appropriate behavioral response based on this information and converting it into a control request may include (i) inputting this information into a processing program (a program written in program code), and the behavior... The characteristics of the pattern are manifested in the program code of the processor. After the processor performs logical operations and determines an inference result based on the information, it can output a control request based on the inference result as a simulation result of the behavioral response determined based on the input information; (ii) the information is input into a processor. The deployment architecture of the processor includes at least one setting. The characteristics of the behavioral pattern are manifested in the at least one setting of the processor. The at least one setting may include some attributes and / or parameters. The program code of the processor reads the at least one setting, determines an inference result based on the information and the content of the at least one setting, and then outputs a control request based on the inference result. The output of the result is a control request, which serves as a simulation result of the behavioral response determined based on the input information; (iii) the information is input into a processing program, the deployment architecture of which includes at least one inference unit, which is at least one type of neural network trained through deep learning and based on at least one inference model, the characteristics of the behavioral pattern are represented in the parameters (e.g., weights, biases, etc.) of the at least one type of neural network, the processing program inputs the input information into the at least one type of neural network, and the at least one type of neural network infers an inference result (e.g., an emotion value) based on the input information, and then the processing program... The system can output a corresponding control request based on the inference result as a simulation result of the behavioral response determined based on the input information; and / or (iv) input the information into a processing program, the deployment architecture of which includes at least one expert system, the characteristics of the behavioral pattern are represented in the rule base (or knowledge base) of the at least one expert system, the processing program inputs the input information into the at least one expert system, infers through the rules contained in the rule base of the at least one expert system, and after inferring an inference result, the processing program can output a control request based on the inference result as a simulation result of the behavioral response determined based on the input information.

[0009] On a smart device, the software system that performs role simulation can commonly take different forms: 1) Taking the Sony AIBO robot dog as an example, the simulated role is a pet dog simulated by the robot dog itself. That is, the hardware and software design of the entire machine is for the simulation of a specific object, "pet dog"; 2) Taking a smart assistant as an example, the simulated role is an assistant simulated by a smart assistant app or service built into the software system of the computing device itself or installed by the user. That is, in this example, the simulation of a specific object, "assistant," can be simulated by an application (App) or application service in a software system. In this article, regardless of whether a role is simulated by a software system in the smart device, an application in that software system, or a combination of both, it can be considered as being simulated by the software system in the smart device, or as being simulated by the smart device itself.

[0010] In the known solutions, methods and products, smart devices (including robot dogs, smart assistants, smart speakers, etc.) receive external scene events and / or scene states through different physical sensors or network signal connectors. After receiving information such as external scene events and / or scene states, they input this information into a predefined processing program. The processing program determines the appropriate behavioral response and converts it into a control request. Based on the converted control request, it drives a change in a structure and / or the execution of an action in the human-machine interface, thereby expressing these behavioral responses. While this predefined processing program can understand environmental changes in the physical and / or virtual worlds through technologies such as speech recognition, image recognition, and / or neural network learning and training, and thus infer and determine appropriate behavioral responses, these responses are ultimately inferred and determined by the predefined processing program of the intelligent device itself. Whether implemented using deep learning-based neural networks, expert systems, or logical operations, this program is still the intelligent device's own behavioral response inferred and determined based on environmental changes. Its goal is to make the simulated role increasingly realistic within its own working environment (or workspace), but it cannot combine the simulated role with the behavioral responses of another role existing in other work scenarios, nor can it extend the role simulation from the intelligent device to other physical or virtual world scenarios. Furthermore, the control requests generated from its own inferred and determined behavioral responses cannot be projected onto physical or virtual world scenarios or other roles, nor can the behavioral responses of another role in other work scenarios be projected onto its own role. In this article, the virtual world refers to virtual scenes or virtual workspaces generated by a multimedia system (e.g., game scenes generated by 2D / 3D games, virtual reality scenes generated by a metaverse system, movie scenes, etc.), while the physical world scene refers to real-world scenes or real-world workspaces. The roles in the physical and virtual worlds can be exemplified by roles simulated by software systems in smart devices in the real world, as well as roles contained within movie, game scenes, or the metaverse.

[0011] Furthermore, in known solutions, methods, and products, regardless of how realistically the role simulated by a smart device is, the fact that a smart device cannot project its simulated role into other workspaces means that, for a computing device that does not simulate any role, it cannot map the simulation results of another smart device for a role into its own workspace; nor can it generate a new role in its workspace and then map the simulation results of other smart devices for that role onto that new role! Conversely, other smart devices themselves cannot map their own simulation results for a role into the workspace generated by a computing device that does not simulate any role, even if a new role is generated in that workspace, the simulation results of that role cannot be mapped onto that new role!

[0012] Taking a robotic dog as an example, a robotic dog can capture movie scenes through a camera or connect to a game console to obtain game scene events and states. Based on the received information, it can infer its own emotions and, according to the plot or game state, wag its tail or comfort its owner, realistically simulating the role of a pet dog, thus achieving the ability to accompany humans to movies or play video games. However, lacking cross-device, cross-scene, and cross-workspace role simulation technologies, methods, and products, a robotic dog cannot truly enter a game scene and play the game with its owner; furthermore, in an interactive movie scene, when an interactive option appears midway through the movie, it cannot enter the movie scene to participate in the discussion and selection with its owner; even further, taking the metaverse as an example, it cannot enter the metaverse scene of a department store with its owner to assist in shopping. Technical issues

[0013] In summary, in the field of character simulation technology, in addition to how to improve the realism of character simulation, the more important issue is that there is currently no effective method or software system for character simulation that allows a character simulated by a computing device to be projected across devices, scenes, workspaces, and / or other characters to run. Therefore, it is still in dire need of development. Technical solutions

[0014] The purpose of this invention is to provide a method for role simulation, as well as a software system and machine for applying this method.

[0015] On one hand, the present invention provides a method for role simulation. First, a first software system establishes an information channel via a connection to receive at least one piece of associated information about a role from a second software system; wherein the first software system and the second software system are orthogonal systems to each other, the first software system executes on a first machine, the second software system executes on a second machine, and the first machine and / or the first software system provides a human-machine interface. Then, the first software system drives a portion of the human-machine interface to make at least one behavioral response based on the at least one piece of associated information, and / or the first software system transmits at least another piece of associated information to the second software system based on the at least one piece of associated information to drive at least another behavioral response of the role and / or another role; wherein the at least one behavioral response is a simulation result of the role and / or the other role by driving at least one structure and / or at least one action in the portion of the component.

[0016] In a preferred embodiment, the first machine or the second machine is a smart speaker, television, game console, computer, mobile phone, robot, metaverse helmet, wearable smart device, and / or any computing device with logic processing capabilities.

[0017] In a preferred embodiment, the first software system and the second software system are any combination of at least one of an operating system, a driver, a software component, a software agent, a software engine, a software service, a software platform, and an application, or any program code block that can run on a computing device.

[0018] In a preferred embodiment, the associated information is a request, event, status, response information, and / or any information received or transmitted through the simulation of the role.

[0019] In a preferred embodiment, the at least one simulation result includes at least one control request, which includes a request for change of the at least one structure and / or a request for execution of the at least one action based on the appearance characteristics and / or behavioral pattern characteristics of the character and / or the other character; wherein the appearance characteristics include shape, color, voice, structure or any static characteristics that can be observed and / or identified by human senses, and the behavioral pattern characteristics include communication, speaking, command calculation, command operation or any dynamic characteristics that can be observed and / or identified by human senses.

[0020] In a preferred embodiment, on the first software system, the execution of the at least one behavioral response represents a mapping of the at least one simulation result, wherein the at least one behavioral response includes changing appearance, changing voice, emitting sound, transmitting information, generating dialog window, calling application programming interface (API), executing transaction, executing calculation or operation of specific instructions, and / or any kind of change request based on the at least one structure and / or execution request of the at least one action, driving the at least one structure and / or the at least one action.

[0021] In a preferred embodiment, the human-machine interface is a medium for interaction and information exchange between a user or another role and the first machine and / or the first software system; the component consists of at least one hardware input / output interface, at least one software input / output interface, at least one graphical user interface, and / or at least one interface for human-machine interaction and information exchange.

[0022] In a preferred embodiment, the at least one structure and / or the at least one action of the component is based on a simulation of the other role.

[0023] In a preferred embodiment, the at least one behavioral response is mapped onto the other role to the at least one simulation result for that role.

[0024] In a preferred embodiment, the other role is a person, an animal, an organic or fictional creature, and / or any object that can be modeled (or “modeled”) based on the other role model.

[0025] In a preferred embodiment, the other role is the modeling result of the first software system of the other role model; wherein, the other role model is any formal expression that can provide observation and / or identification basis for the appearance and / or behavior pattern of the other role.

[0026] In a preferred embodiment, the first software system models the other role based on a formal expression of the other role model, and presents the modeling result through the human-computer interface.

[0027] In a preferred embodiment, when the component does not exist in the human-computer interface, the component is automatically generated based on the description information of the role model.

[0028] In a preferred embodiment, the description information of the other character model includes a description of the character's appearance and / or behavioral patterns.

[0029] In a preferred embodiment, the description information of the other character model is provided by the second software system.

[0030] In a preferred embodiment, the other character is an avatar of the character, a mapped character, or a possessed character.

[0031] In a preferred embodiment, the other role model is dynamically loaded into the first software system. Prior to the dynamic loading of the other role model, the other role model does not exist in the first software system.

[0032] In a preferred embodiment, the other role model is dynamically loaded from the second software system into the first software system.

[0033] In a preferred embodiment, the dynamically loaded other role model in the first software system is a copy of the role model.

[0034] In a preferred embodiment, in the first software system, the other role model is driven by a dynamically loaded self-contained component.

[0035] In a preferred embodiment, the at least other association information is the association information of the other role.

[0036] In a preferred embodiment, the at least other associated information is a request, event, status, response information, and / or any information received or transmitted through the imitation of the other role.

[0037] In a preferred embodiment, the content of the at least one associated information and / or the at least another associated information includes a description of an appearance and / or behavioral pattern feature, a structural specification description, and / or a driver for an action (e.g., a character's skill); wherein the description of the appearance and / or behavioral pattern feature, the structural specification description, and / or the driver for the action are presented in the form of a program file, a script file, settings, parameters, an implementation of a structure or class, a data package (e.g., an HTTP request, a specification description prompt), or any combination thereof.

[0038] In a preferred embodiment, the second machine and / or the second software system provides another human-machine interface, the other human-machine interface including another component, the at least another behavioral response being a simulation result of the role and / or the other role by driving at least another structure and / or at least another action in the other component.

[0039] In a preferred embodiment, a workspace for a scenario is constructed through the human-machine interface; another workspace for a different scenario is constructed through the other human-machine interface; wherein the workspace and the other workspace are orthogonal to each other; wherein the other role enters the workspace from the other workspace to run during execution, and / or the role enters the other workspace from the workspace to run during execution.

[0040] In a preferred embodiment, the at least another simulation result includes at least another control request, which includes a request for change of the at least another structure and / or a request for execution of the at least another action based on the appearance characteristics and / or behavioral pattern characteristics of the character and / or the other character; wherein the appearance characteristics include shape, color, voice, structure or any static characteristics that can be observed and / or identified by human senses, and the behavioral pattern characteristics include communication, speaking, command calculation, command operation or any dynamic characteristics that can be observed and / or identified by human senses.

[0041] In a preferred embodiment, on the second software system, the execution of the at least other behavioral response represents a mapping of the at least other simulation result, wherein the at least other behavioral response includes changing appearance, changing voice, emitting sound, transmitting information, generating dialog window, calling application programming interface (API), executing transaction, executing calculation or operation of specific instructions, and / or any kind of change request based on the at least other structure and / or execution request of the at least other action, driving the at least other structure and / or the at least other action.

[0042] In a preferred embodiment, the other human-machine interface is a medium for interaction and information exchange between a user or role and the second machine and / or the second software system; the other part consists of at least one hardware input / output interface, at least one software input / output interface, at least one graphical user interface, and / or at least one interface for human-machine interaction and information exchange.

[0043] In a preferred embodiment, the at least other structure and / or the at least other action of the other part is based on a simulation of the role.

[0044] In a preferred embodiment, the at least other behavioral response is a mapping of the at least other simulation result for that other role onto that role.

[0045] In a preferred embodiment, the role is a person, an animal, an organic or fictional creature, and / or any object that can be modeled (or “modeled”) based on a role model.

[0046] In a preferred embodiment, the role is a modeling result of the role model by the second software system; wherein, the role model is any formal expression that can provide observation and / or identification basis for the appearance and / or behavior pattern of the role.

[0047] In a preferred embodiment, the second software system models the role based on the formal expression of the role model, and presents the modeling result through the other human-computer interface.

[0048] In a preferred embodiment, when the other component does not exist in the other human-machine interface, the other component is automatically generated based on the description information of the other role model.

[0049] In a preferred embodiment, the descriptive information of the character model includes a description of the appearance and / or behavioral patterns of the other character.

[0050] In a preferred embodiment, the description information of the character model is provided by the first software system.

[0051] In a preferred embodiment, the character is an avatar, a mapped character, or a possessed character of the other character.

[0052] In a preferred embodiment, the role model is dynamically loaded into the second software system. Prior to the dynamic loading of the role model, the role model does not exist in the second software system.

[0053] In a preferred embodiment, the role model is dynamically loaded from the first software system into the second software system.

[0054] In a preferred embodiment, the dynamically loaded role model in the second software system is a copy of the other role model.

[0055] In a preferred embodiment, in the second software system, the role model is driven by another dynamically loaded self-contained component.

[0056] In a preferred embodiment, the role is an artificial intelligence (AI), an AI agent, an intelligent assistant, a person, an animal, an organic or fictional creature, and / or any object that can be modeled (or "modeled") based on a role model, and / or the other role is another artificial intelligence (AI), another AI agent, another intelligent assistant, another person, another animal, another organic or fictional creature, and / or any other object that can be modeled (or "modeled") based on another role model.

[0057] In a preferred embodiment, the descriptive information of the character model includes a description of the appearance and / or behavior patterns of the other character; and / or the descriptive information of the other character model includes a description of the appearance and / or behavior patterns of the character.

[0058] In a preferred embodiment, the descriptive information of the character model is provided by the first software system; and / or the descriptive information of the other character model is provided by the second software system.

[0059] In a preferred embodiment, when the component does not exist in the human-machine interface, the component is automatically generated based on the descriptive information of the role model; and / or the second machine and / or the second software system provides another human-machine interface, and when another component does not exist in the other human-machine interface, the other component is automatically generated based on the descriptive information of the other role model.

[0060] In a preferred embodiment, all or part of the role model is dynamically loaded into the second software system, where the role model does not exist in the second software system before dynamic loading; and / or all or part of the other role model is dynamically loaded into the first software system, where the other role model does not exist in the first software system before dynamic loading.

[0061] In a preferred embodiment, all or part of the character model is dynamically loaded from the first software system to the second software system; and / or all or part of the other character model is dynamically loaded from the second software system to the first software system.

[0062] In a preferred embodiment, in the second software system, all or part of the role model is driven by a dynamically loaded self-contained component; and / or in the first software system, all or part of the other role model is driven by another dynamically loaded self-contained component.

[0063] In a preferred embodiment, in the second software system, the role model is a copy of all or part of the other role model; and / or in the first software system, the other role model is a copy of all or part of the other role model.

[0064] In a preferred embodiment, the role is the modeling result of the role model by the second software system, and the role model is a formal expression; and / or the other role is the modeling result of the other role model by the first software system, and the other role model is another formal expression.

[0065] In a preferred embodiment, the formal expression and / or the other formal expression includes a description of appearance and / or behavioral pattern characteristics, a structural specification description, and / or a driver for actions (e.g., a character's skill).

[0066] In a preferred embodiment, based on the description of the appearance and / or behavioral pattern characteristics, the specification description of the structure, and / or the driver program of the action (e.g., the character's skill), the appearance, behavioral pattern, structure, and / or operation corresponding to the character and / or the other character are displayed on the corresponding human-computer interface.

[0067] In a preferred embodiment, the formal expression and / or the content of the other formal expression are presented as an implementation of a program file, script file, settings, parameters, struct or class, and / or a data package (e.g., an HTTP request, a specification prompt), or any combination thereof.

[0068] In a preferred embodiment, the content of the formal expression and / or the other formal expression includes parameters in a neural network (e.g., weights, biases), rules in an expert system rule base, implementations of object categories, programmatic scripts, structured scripts, structured objects (e.g., JSON Objects), unstructured strings (e.g., prompts for role specifications), or any combination thereof.

[0069] In a preferred embodiment, the format of the formal expression and / or the other formal expression refers to a specification, style and / or form for arranging, expressing and / or representing the corresponding formal expression content.

[0070] In a preferred embodiment, the format of the formal expression and / or the other formal expression includes the neuronal structure in a neural network, the knowledge representation of an expert system, the syntax of a programming language, an unstructured data structure, a structured data structure, or any combination thereof.

[0071] In a preferred embodiment, the first software system models the other role based on the other formal expression and displays the modeling result of the other role model through the human-computer interface; and / or the second software system models the role based on the formal expression and displays the modeling result of the role model through another human-computer interface provided by the second machine and / or the second software system.

[0072] In a preferred embodiment, the second machine and / or the second software system provides another human-machine interface, the other human-machine interface including another component, the at least another behavioral response being a simulation result of the role and / or the other role by driving at least another structure and / or at least another action in the other component.

[0073] In a preferred embodiment, the at least other simulation result is at least another control request; wherein the at least other control request includes a request for change to the at least other structure and / or a request for execution of the at least other action.

[0074] In a preferred embodiment, the at least one other control request is generated based on the at least one associated information; and / or the at least one other control request is generated based on the appearance characteristics and / or behavioral pattern characteristics of the role and / or the other role, the appearance characteristics including shape, color, voice, structure or any static characteristics that can be observed and / or identified by human senses, and the behavioral pattern characteristics including communication, speaking, command calculation, command operation or any dynamic characteristics that can be observed and / or identified by human senses.

[0075] In a preferred embodiment, the at least one structure and / or the at least one action represented by the other component is based on a simulation of the role.

[0076] In a preferred embodiment, a workspace for a scenario is constructed through the human-machine interface; the second machine and / or the second software system provides another human-machine interface, through which another workspace for a different scenario is constructed; wherein the workspace and the other workspace are orthogonal to each other; wherein the other role enters the workspace from the other workspace to run during execution, and / or the role enters the other workspace from the workspace to run during execution.

[0077] In a preferred embodiment, the orthogonal systems refer to the first software system and the second software system being functionally independent and undependent; they transmit data between each other based on support for a communication protocol.

[0078] On the other hand, the present invention also provides another method for role simulation. First, a first software system establishes an information channel via a connection to transmit at least one piece of associated information about a role to a second software system; wherein the first software system and the second software system are orthogonal systems to each other, the first software system executes on a first machine, the second software system executes on a second machine, and the second machine and / or the second software system provides a human-computer interface. Then, the second software system drives a portion of the human-computer interface to make at least one behavioral response based on the at least one piece of associated information, and / or the second software system transmits at least another piece of associated information to the first software system based on the at least one piece of associated information to drive at least another behavioral response of the role and / or another role; wherein the at least one behavioral response is a simulation result of the role and / or the other role by driving at least one structure and / or at least one action in the portion of the component.

[0079] Furthermore, the present invention provides a software system or machine that applies the aforementioned role simulation method.

[0080] Furthermore, the present invention also relates to a method for communication between roles, comprising at least the following steps: transmitting a first association information of a first role to a second role through an information channel; wherein the first role and the second role are roles that operate independently; and a second role performing a corresponding process based on the first association information, outputting an execution result of the process as a second association information, and transmitting the second association information back to the first role through the information channel.

[0081] In a preferred embodiment, the first role is an artificial intelligence (AI), an AI agent, an intelligent assistant, and / or any object that can be modeled (or "modeled") based on the first role model, and / or the second role is another artificial intelligence (AI), another AI agent, another intelligent assistant, and / or any other object that can be modeled (or "modeled") based on the second role model.

[0082] In a preferred embodiment, the first character model and / or the second character model includes a description of appearance and / or behavioral pattern characteristics, a structural specification description, and / or a driver for actions (e.g., the character's skill).

[0083] In a preferred embodiment, based on the description of the appearance and / or behavioral pattern characteristics, the specification description of the structure, and / or the driver program of the action (e.g., the character's skill), the appearance, behavioral pattern, structure, and / or operation of the first character and / or the second character are displayed on the corresponding human-computer interface.

[0084] In a preferred embodiment, the content of the first role model and / or the second role model is presented as an implementation of a program file, script file, settings, parameters, structure, or class, and / or a data package (e.g., an HTTP request, a specification description prompt), or any combination thereof.

[0085] In a preferred embodiment, the content of the first role model and / or the second role model includes parameters in a neural network (e.g., weight values, bias), rules in an expert system rule base, implementations of object categories, programmatic scripts, structured scripts, structured objects (e.g., JSON Objects), unstructured strings (e.g., prompts describing role specifications), or any combination thereof.

[0086] In a preferred embodiment, the format of the first character model and / or the second character model refers to a specification, style and / or form for arranging, expressing and / or representing the corresponding character model content.

[0087] In a preferred embodiment, the format of the first role model and / or the second role model includes the neuron structure in a neural network, the knowledge representation of an expert system, the syntax of a programming language, an unstructured data structure, a structured data structure, or any combination thereof.

[0088] In a preferred embodiment, the information channel is a network transmission channel established based on at least one communication protocol, and at least one information data transmission is implemented based on the at least one communication protocol.

[0089] In a preferred embodiment, the first associated information and / or the second associated information is a request, event, status, response information, and / or any type of information received or transmitted through role simulation. In a preferred embodiment,

[0090] In a preferred embodiment, the content of the first association information and / or the second association information includes a description of an appearance and / or behavioral pattern feature, a structural specification description, and / or a driver for an action (e.g., a character's skill); wherein the description of the appearance and / or behavioral pattern feature, the structural specification description, and / or the driver for the action are presented in the form of a program file, a script file, settings, parameters, an implementation of a structure or class, a data package (e.g., an HTTP request, a specification description prompt), or any combination thereof.

[0091] In a preferred embodiment, the first association information and / or the second association information is at least one control request, which includes a request for a change to at least one structure and / or a request for the execution of at least one action.

[0092] In a preferred embodiment, the first associated information is a request, the content of which includes at least one identifier and at least one parameter.

[0093] In a preferred embodiment, the at least one identifier and / or the at least one parameter includes a task method to be executed by the request and the parameter content required to execute the task method.

[0094] In a preferred embodiment, the at least one identifier and / or the at least one parameter includes auth info representing that the request has been authorized.

[0095] In a preferred embodiment, the second software system includes a published list of resources, which includes at least one resource, the contents of which contain description information of at least one executable task method.

[0096] In a preferred embodiment, the at least one task method includes at least one structure, at least one action, at least one tool, and / or at least one information access method supported by the second software system and / or the second role.

[0097] In a preferred embodiment, the process includes changes to the at least one structure, the execution of the at least one action, the driving of the at least one tool, and / or access to the at least one piece of information.

[0098] In a preferred embodiment, before transmitting the first association information to the second software system, the first software system queries the resource list from the second software system.

[0099] In a preferred embodiment, before the first association information is generated, after the first role receives an instruction from the user, it inputs the instruction and the resource list into a neural network. Through the inference of the neural network, it finds a resource suitable for executing the instruction and generates the first association information based on the description information of an executable task method contained in the resource.

[0100] In a preferred embodiment, the neural network is characterized as a large language model (LLM).

[0101] In a preferred embodiment, the content of the second associated information is a response information, and the content of the response information includes the execution result.

[0102] In a preferred embodiment, the first role operates in a first software system, and the second role operates in a second software system; wherein the first software system executes on a first machine, and the second software system executes on a second machine.

[0103] In a preferred embodiment, the first software system and the second software system are orthogonal systems to each other. Orthogonal systems mean that the first software system and the second software system are functionally independent and do not depend on each other; they transmit data between each other based on the support of a communication protocol.

[0104] Furthermore, the present invention also relates to a method for extending the function of a role, comprising at least the following steps: transmitting a role’s associated information to another software system through an information channel; wherein the associated information includes at least one request; and the other software system, based on the at least one request, transmitting another role model back to the role through the information channel, wherein the role extends at least one function based on the other role model.

[0105] In a preferred embodiment, the role is an artificial intelligence (AI), an AI agent, an intelligent assistant, and / or any object that can be modeled (or “modeled”) based on a role model.

[0106] In a preferred embodiment, the character model and / or the other character model includes a description of appearance and / or behavioral pattern characteristics, a structural specification description, and / or a driver for actions (e.g., the character's skill).

[0107] In a preferred embodiment, based on the description of the appearance and / or behavioral pattern characteristics, the specification description of the structure, and / or the driver program of the action (e.g., the character's skill), the appearance, behavioral pattern, structure, and / or operation of the character are represented to the corresponding human-computer interface.

[0108] In a preferred embodiment, the content of the role model and / or the other role model is presented as an implementation of a program file, script file, settings, parameters, struct or class, and / or a data package (e.g., HTTP Request, specification prompt), or any combination thereof.

[0109] In a preferred embodiment, the content of the role model and / or the other role model includes parameters in a neural network (e.g., weight values, bias), rules in an expert system rule base, implementations of object categories, procedural scripts, structured scripts, structured objects (e.g., JSON Objects), unstructured strings (e.g., prompts describing role specifications), or any combination thereof.

[0110] In a preferred embodiment, the format of the character model and / or the other character model refers to a specification, style and / or form for arranging, expressing and / or representing the corresponding character model content.

[0111] In a preferred embodiment, the format of the role model and / or the other role model includes a neuronal structure in a neural network, a knowledge representation in an expert system, the syntax of a programming language, an unstructured data structure, a structured data structure, or any combination thereof.

[0112] In a preferred embodiment, the information channel is a network transmission channel established based on at least one communication protocol, and at least one information data transmission is implemented based on the at least one communication protocol.

[0113] In a preferred embodiment, the other role model is transmitted to the role via another set of associated information.

[0114] In a preferred embodiment, the associated information and / or the other associated information is a request, event, status, response information, and / or any kind of information received or transmitted through the simulation of a role.

[0115] In a preferred embodiment, the content of the associated information and / or the other associated information includes a description of an appearance and / or behavioral pattern feature, a structural specification description, and / or a driver for an action (e.g., a character's skill); wherein the description of the appearance and / or behavioral pattern feature, the structural specification description, and / or the driver for the action are presented in the form of a program file, a script file, settings, parameters, an implementation of a structure or class, a data package (e.g., an HTTP request, a specification description prompt), or any combination thereof.

[0116] In a preferred embodiment, the at least one request includes a request to obtain the other character model.

[0117] In a preferred embodiment, the extension of at least one function is accomplished by dynamically loading the other character model, which does not exist in the character model before the dynamic loading.

[0118] In a preferred embodiment, the other software system includes a published list of resources, which includes at least one resource, the content of which includes description information of at least one character model; wherein the at least one character model includes a driver program for at least one action (the character's skill).

[0119] In a preferred embodiment, before transmitting the association information to the other software system, the role queries the resource list from the other software system.

[0120] In a preferred embodiment, before the association information is generated, after the role receives an instruction from the user, it feeds the instruction and the resource list into a neural network. Through the inference of the neural network, it finds a role model suitable for executing the instruction, and then generates the association information.

[0121] In a preferred embodiment, such a neural network is a large language model (LLM).

[0122] In a preferred embodiment, the role operates in a software system; wherein the software system executes on a first machine and the other software system executes on a second machine.

[0123] In a preferred embodiment, the software system and the other software system are orthogonal systems to each other. Orthogonal systems are those that are functionally independent and do not depend on each other; they transmit data between each other based on the support of a communication protocol.

[0124] The above-mentioned objectives and advantages of this application will become more apparent to those skilled in the art upon consideration of the following detailed description and accompanying drawings. Beneficial effects

[0125] The method created by this invention allows: 1) an intelligent device to output the behavioral responses of a simulated character through another character in a virtual or real-world scene; 2) an intelligent device to allocate its intelligence to different computing devices, participating in different virtual or real-world scenes as an attached character, an automatically generated avatar, or a character it maps to, and cooperating in those different scenes; 3) the character represented by the intelligent device can be a character existing in a real-world scene (e.g., a robot dog) or a character in a virtual scene (e.g., an intelligent assistant or an artificial intelligence in a computer, mobile phone, or server). The other character can also be a character in a virtual or real-world scene. In this way, two different characters in a real-world scene, two different characters in a virtual scene, or two different characters belonging to different virtual and real-world scenes can all project their behavioral responses through each other, so that the service simulated by the character transcends the boundaries and barriers between different devices. Attached Figure Description

[0126] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0127] Figure 1 is a flowchart of a preferred method for role simulation in this case.

[0128] Figure 2 is a schematic diagram illustrating the relationship between one of the roles, the role model, and the formal expression in this case.

[0129] Figure 3A is a schematic diagram of the operational concept of simulating a role using a machine and / or a software system in this case.

[0130] Figure 3B is a preferred embodiment of "modeling (or modeling) a character based on a character model" corresponding to Figure 3A.

[0131] Figure 3C is a preferred embodiment of "generating at least one simulation result based on a role model of a character to drive at least one behavioral response" corresponding to Figure 3A.

[0132] Figure 4 is a conceptual diagram illustrating the related information of a character in this case.

[0133] Figure 5 is a schematic diagram of the operational concept of attaching the role of one system to the role of another system in this case.

[0134] Figure 6 is a schematic diagram of the operational concept of the character generation and avatar system in this case.

[0135] Figure 7 is a schematic diagram of the operational concept of this case, in which the role of one system is possessed by the role of another system in reverse.

[0136] in,

[0137] 1: Machine

[0138] 2: Software System

[0139] 3: Workspace (Application)

[0140] 11: Robot Dog

[0141] 21: Robot Dog Operating System

[0142] 31: Game Scene

[0143] 51: Pet Dog (Character)

[0144] 12: Music Bear

[0145] 52: Bear (character)

[0146] 13: Game console

[0147] 23: Game software

[0148] 53, 532: Player (Character)

[0149] 533: Transformed into a dog

[0150] 4, 41, 42, 43, CM4: Character Models

[0151] 61, 63, 64: Processing Procedures

[0152] 71, 73, 74: Control Requests

[0153] 712, 713, 715: Related Information

[0154] 732, 733, R7: Simulation Results

[0155] 8: User

[0156] 91, 92, E6: Request, event, status, and / or response information

[0157] A8: Behavioral Response

[0158] C5: Role

[0159] DM: Description Information

[0160] FE: Formal Expression

[0161] P1, P2: Procedure (Steps)

[0162] S1, S2, S3: Procedure (steps). Embodiments of the present invention

[0163] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0164] The following descriptions of the embodiments are with reference to the accompanying drawings, illustrating specific embodiments in which this application can be implemented. Directional terms used in this application, such as "up," "down," "front," "back," "left," "right," "inner," "outer," and "side," are merely for reference to the accompanying drawings. Therefore, the directional terms used are for illustrative and understanding purposes only, and not for limiting the scope of this application.

[0165] The accompanying drawings and descriptions are intended to be illustrative in nature, not restrictive. In the drawings, structurally similar units are denoted by the same reference numerals. Furthermore, for ease of understanding and description, the dimensions and thicknesses of each component shown in the drawings are arbitrary, but this application is not limited thereto.

[0166] Additionally, in the specification, unless explicitly stated otherwise, the word "comprising" will be understood to mean including the stated component, but not excluding any other components. Furthermore, in the specification, "on" means located above or below the target component, and does not mean that it must be located on top based on the direction of gravity.

[0167] To further illustrate the technical means and effects adopted by this application to achieve the intended disclosure purpose, the following, in conjunction with the accompanying drawings and preferred embodiments, details the specific implementation, structure, features and effects of a role simulation method and a software system and machine applying the method proposed in this application.

[0168] This application will be more fully understood through the following description, including the following glossary of terms and concluding examples. For the sake of brevity, all publications cited in this specification, including patent disclosures, are incorporated herein by reference.

[0169] The following embodiments of this application are non-limiting and merely represent various specific implementations and features of this application. In its most limited technical sense, the role simulation method described in this application allows a role simulated by a computing device to be projected across devices, scenes, workspaces, and / or other roles to run on different devices, scenes, workspaces, and / or other roles, as further described in detail with reference to the preferred embodiments herein.

[0170] Please refer to Figure 1, which is a preferred method flowchart of the character simulation method of the present invention. The character simulation method of this invention may include at least the following steps:

[0171] Step P1: The first software system establishes an information channel via a connection to receive at least one associated information from a role in the second software system; wherein the first software system and the second software system are orthogonal systems to each other, the first software system executes on a first machine, the second software system executes on a second machine, and the first machine and / or the first software system provides a human-machine interface; and

[0172] Step P2: The first software system drives a portion of the human-machine interface to make at least one behavioral response based on the at least one associated information, and / or the first software system transmits at least another associated information to the second software system based on the at least one associated information to drive at least another behavioral response of the role and / or another role; wherein, the at least one behavioral response is to reflect at least one simulation result of the role and / or the other role by driving at least one structure and / or at least one action in the portion of the component.

[0173] In its most limited technical sense, the “machine” referred to herein is an embedded device, a multimedia device, a smart device, and / or any computing device with logical operation processing capabilities, including at least a smart speaker, television, game console, computer, mobile phone, robot, metaverse helmet, wearable smart device, or any combination thereof. In this document, "machine" can refer to an intelligent device. An "intelligent device" is a computing device composed of a hardware system and a software system. The original design purpose of an intelligent device is to model a role to serve a user through a human-computer interface composed of its structural style, hardware input / output interfaces, software input / output interfaces, and / or graphical user interfaces, based on a formal expression of a role model. This includes intelligent robots, robotic dogs, or any device (e.g., mobile phones, laptops) equipped with intelligent assistant applications (Apps) or application services, which simulate a role in appearance and behavior to serve a user. All such products can be called "intelligent devices." Specifically, an intelligent robot is designed to simulate a person, a robotic dog to simulate a pet, and an intelligent assistant to simulate an assistant. By embedding or installing an intelligent assistant on a mobile phone / computer, the phone / computer becomes an intelligent device with intelligent assistant service capabilities. However, the "machine" described in this document is not limited to intelligent devices. Any computing device with logical processing capabilities, even if its original design purpose is not to model a role through its human-computer interface, can also be considered. However, to achieve a better user experience, a role can be simulated within a workspace constructed through its human-computer interface, based on a formalized representation of a role model. This role can then be modeled within the workspace to communicate and / or interact with the user. For example, a game console playing a baseball game can construct a baseball game scenario (workspace) through its human-computer interface, where the opponents, umpires, and spectators are all simulated roles within that scenario. However, the implementation of machines and intelligent devices described in this article is not limited to the above.

[0174] The "orthogonal systems" discussed in this article refer to systems that are independent and undependent within a specific context. In the field of calculators, orthogonal systems typically mean that two systems are functionally independent and undependent; there is no dependency between them in terms of functional implementation; and the operation of one system does not depend on the data or resources of the other. When two software systems are orthogonal to each other, it usually also means that the two software systems are independent, separated, and undependent in terms of system deployment and operational architecture.

[0175] As mentioned above, an orthogonal system refers to two systems that are functionally independent and do not depend on each other. However, this does not mean that they cannot communicate and interact with each other. They can communicate and collaborate by transmitting data between each other based on a communication protocol.

[0176] Continuing from the above, for example, the game software in a game console and the robot dog operating system in a robot dog are orthogonal systems. The game software and the robot dog operating system, within their respective machines, function independently and are not dependent on each other. The lack of data or resources from the other will not cause the system to malfunction. According to the implementation method of this invention, the two systems can achieve simulation of characters entering each other's scenes based on limited communication. This limited communication does not affect the independence of their respective functions, nor does it create a dependency on each other in their respective system operations. The lack of data or resources from the other will not cause the system to malfunction. However, the implementation of the orthogonal system described herein is not limited to the above.

[0177] Continuing from the above, in this article, non-orthogonal is the opposite of orthogonal. Non-orthogonal systems can be interpreted as systems that are not orthogonal. Examples of non-orthogonal systems include: (i) a front-end system (Web App, Mobile App) developed based on a "Client-Server Architecture". (i) Apps and a backend system. During execution, the frontend system and the backend system run on separate frontend and backend machines, and may even be implemented in two different programming languages. However, the operation of the frontend system depends on the backend system to provide data and functions. Therefore, the frontend system and the backend system are non-orthogonal software systems. (ii) The frontend system of the same backend system may include different types such as web frontend applications or mobile native applications. Although these frontend systems that run on the client machine in different forms do not have a direct dependency relationship during execution, they still have an indirect dependency relationship through the backend system. They all depend on the same backend system to provide data and functions, and share the same backend services and business logic. Even if they run on different client machines, they are only different in computing environment and do not have functional independence. Therefore, these (iii) The same software system running on different machines is still the same software system, and it is not independent in function. The same software system on different machines shares the same program code and functions, but the computing environment is different. Therefore, they are not orthogonal systems. (iv) A back-end system can be implemented by a distributed architecture. Although the nodes in the distributed architecture usually have a certain degree of independence, these nodes need to rely on each other's data to complete specific tasks. Even if the distributed architecture has fault tolerance for some nodes, the failure of some nodes will not affect the operation of the overall system. However, this does not mean that they are completely orthogonal systems, because they still have a coupling relationship. They may only use off-site backup deployment strategy to ensure that the system service is not interrupted. Therefore, they are not orthogonal systems.

[0178] Continuing from the above, two orthogonal software systems can contain other non-orthogonal software systems. For example, the iOS and Android operating systems can be considered two orthogonal operating systems, but within these two operating systems, front-end applications from the same back-end system can be installed. Although these front-end applications are non-orthogonal software systems, this does not affect the fact that the iOS and Android operating systems are orthogonal systems to each other. Conversely, two non-orthogonal software systems can also contain other orthogonal software systems. For example, if two mobile phones have the same Android operating system installed, then the Android operating systems on these two phones are non-orthogonal systems. Within this same Android operating system, a game and a calendar can be installed. The game and the calendar are two orthogonal applications. Although the Android operating systems on these two phones are non-orthogonal software systems, this does not affect the fact that the game and the calendar are orthogonal systems to each other. Determining orthogonality should focus on the relationships between software systems as a whole, emphasizing their interdependence and influence rather than the details of their internal components; if two software systems A and B are orthogonal, then changes to A should not affect B, and vice versa.

[0179] Building on the above, to determine whether two software systems are orthogonal, we should consider aspects such as module independence, dependencies, and testing and verification. The software modules of orthogonal systems should be independent of each other, and changes to one system should not affect the other. There should be no direct dependencies between the two systems; one system should not depend on the specific implementation details of the other. The two systems can be tested independently, unaffected by the other. Combining these criteria allows for an objective assessment of whether two software systems are orthogonal.

[0180] The "workspace" mentioned in this article refers to a workspace constructed through a human-computer interface that enables information transmission and / or interaction with the outside world. When one software system and another software system are orthogonal systems, it means that the workspace generated by the software system and its host machine is also orthogonal to the workspace generated by the other software system and its host machine. That is, the operation of the two workspaces is independent of each other and they do not depend on each other. The lack of data or resources from the other will not cause the workspace to fail to operate.

[0181] Continuing from the above, in a preferred embodiment, a workspace can be constructed by at least one graphical user interface in a human-machine interface, which can be used to display at least one character; wherein, on a television screen, computer or mobile phone screen, or AR / VR headset, the workspace constructed by the at least one graphical user interface may include a movie scene, a game scene, or a workspace in a virtual world such as AR / VR virtual reality, and the at least one character may include a character in a movie scene, game screen, or virtual reality screen.

[0182] Continuing from the above, in a preferred embodiment, a workspace can be constructed in the physical world by at least one interface of a human-machine interface (HMI) for information transmission and / or interaction with the user. The appearance and / or behavior of this HMI in the physical world constitute an observable and / or identifiable character (e.g., a robot dog). The scenario of this character interacting with the outside world through the at least one interface constructs the workspace in the physical world.

[0183] Continuing from the above, in another preferred embodiment, a machine can simultaneously construct a composite workspace in both the physical and virtual worlds. That is, a software system within the machine can generate at least one graphical user interface on a screen and construct a virtual workspace in the virtual world within that at least one graphical user interface. In the physical world, the machine also has at least one other interface for information transmission and / or information interaction with the outside world. For example, in the physical world, the machine can interact with the user through at least one interface, thus forming a real workspace in the physical world. The real workspace and the virtual workspace in the physical and virtual worlds can be considered as a composite scene constructed by the machine, or as the real workspace and the virtual workspace together forming a composite workspace.

[0184] Continuing from the above, in another preferred embodiment, a software system can, for a specific scenario, enable multiple machines to collaboratively build a workspace via a network through a client-server model or other distributed architecture. This software system allows multiple client devices to share data and / or resources through at least one server, or it can enable these multiple distributed machines to share data and / or resources through network collaboration using a distributed storage architecture, thus constructing a workspace that can run across machines. However, the implementation of the workspace described herein is not limited to the above.

[0185] The term "software system" as used herein includes any combination of at least one of the following: operating system, driver, software component, software agent, software engine, software service, software platform, and application; or any block of program code that can run on a computing device. Furthermore, the term "multimedia system" as used herein includes a video game, a website, a video streaming media platform, an AR / VR system, or any software system that uses computer technology and / or network technology to process and control multimedia information. Furthermore, the term "backend system" as used herein includes a blockchain network system, a database system, a microservice, an internet backend system, or any network application service that can interact with a software system, integrate with an application programming interface, or synchronize data, wherein the backend system is constructed from an independent server, a distributed system architecture, and / or a cloud infrastructure environment. Furthermore, the "connection" mentioned herein includes at least a network transmission signal stream established in Bluetooth, the Internet, 4G / 5G mobile communication networks, WIFI, infrared, satellite, or any network system with signal switching capabilities; and the "information channel" mentioned herein includes a network transmission channel that allows at least one information data transmission to be performed in the network transmission signal stream after at least one communication protocol is imported into it, or any channel that achieves information transmission through signal switching while connected. Also, the "processor" mentioned herein includes any combination of at least one of software components, software agents, software engines, software services, software platforms, and applications, or any program that can be loaded and run by the software system described herein; in a preferred embodiment, a processor may be part of a software system, that is, the processor is a module built into the software system, or the program code of the software system itself contains the processor; in another preferred embodiment, the processor is installed or dynamically loaded into the software system. However, the implementation of the software system, multimedia system, backend system, connection and information channel described in this article is not limited to the above.

[0186] The "human-computer interface" (HCI) described herein is a medium through which a user or role interacts and exchanges information with a machine and / or a software system. An HCI includes at least one hardware input / output interface, at least one software input / output interface, at least one graphical user interface, and / or at least one type of interface used for human-computer interaction and information exchange. Furthermore, the "partial components" described herein refer to the entirety of a HCI or a portion thereof; the partial components of a HCI are the interfaces contained within it. That is, a portion of a human-computer interface may consist of all the hardware input / output interfaces, software input / output interfaces, graphical user interfaces, and / or any interface used for human-computer interaction and information exchange included in the human-computer interface; or the portion may consist of at least one hardware input / output interface, at least one software input / output interface, at least one graphical user interface, and / or at least one interface used for human-computer interaction and information exchange in the human-computer interface; or the portion may consist of a portion of the interfaces in the human-computer interface, including at least one hardware input / output interface, at least one software input / output interface, at least one graphical user interface, and / or at least one interface used for human-computer interaction and information exchange.

[0187] Continuing from the above, in one preferred embodiment, the overall design of the human-machine interface of the Sony AIBO robot dog is used to simulate a pet dog. In another preferred embodiment, Xiaomi's robot vacuum cleaner and mobile phone equipped with a smart assistant application or service, although the overall appearance of the machine itself is a round sweeping machine or mobile phone rather than a person, can simulate a human assistant through certain interfaces in the human-machine interface (e.g., speaker and microphone, or even a chat window displayed in a certain part of the graphical user interface rendered by the software system on the mobile phone screen), using sound, text, or images to assist humans in handling sweeping or daily life tasks. In another preferred embodiment, the game software constructs a baseball game scene (workspace) on the television screen through its rendered graphical user interface. The opponents, referees, or spectators simulated in this scene can also be said to be simulated through partial display blocks in the graphical user interface, with the roles of opponents, referees, or spectators displayed in their corresponding partial display blocks; wherein, the partial display blocks can be regarded as a part of the interface in the graphical user interface; since the graphical user interface is a scene rendered by the software (game software), it can also be regarded as a kind of software input / output interface. In another preferred embodiment, a smart speaker (e.g., Google Nest Audio), as a smart device, although lacking the appearance of a human, simulates a home assistant through its behavior. Besides interacting with the user through its speaker, when receiving a user's instruction to check the weather, it also queries an external server for weather information through a client application programming interface (API) implemented within the smart device. The speaker output of sound can be considered an interaction and information exchange between the user and a hardware input / output interface, while the user's query for external weather through the API can be considered an interaction and information exchange between the user and a software input / output interface. However, the embodiments of the human-computer interface and its components described herein are not limited to the above.

[0188] The term "role" as used herein refers to an object whose appearance and / or behavioral patterns can be observed and / or identified; wherein, the object includes at least a person, an animal, an organic or fictional creature, and / or any object that can be modeled (or "modeled") based on a role model; wherein, the object includes virtual objects; the virtual object may be a chatbot in an app, although the chatbot may not necessarily have the appearance of a person, and the interface for interacting with the user may only be a chat window, but its behavioral patterns can be observed and identified as a role capable of chatting and interacting with the user, or the virtual object may be an artificial intelligence (AI), an intelligent system with intelligence, although the AI ​​may not necessarily have any form of appearance, but when performing a specific task, its behavioral patterns can exhibit behaviors similar to human intelligence. For example, it may be a neural network system with learning capabilities, trained to solve specific tasks. The field of artificial intelligence also includes other forms of intelligent systems, not limited to neural networks.

[0189] The "role model" described herein refers to a formal expression that provides observational and / or identification criteria for the appearance and / or behavioral patterns of a specific object; the specific object is a specific role; the content of the formal expression includes any descriptive information about the appearance and / or behavioral patterns of the specific object, and the content of the descriptive information includes a description of the appearance and / or behavioral patterns of the specific object; the format of the formal expression refers to a specification, style, and / or form for arranging, expressing, and / or representing the formal expression content, which may be a data structure, a data model, the syntax of a programming language, or any combination thereof. Table 1 below shows various different implementations of the formal expression format and formal expression content disclosed in the embodiments of this paper. However, the format and content of the formal expression are not limited to those listed in Table 1 below, and those skilled in the art can make any equivalent changes according to actual application needs.

[0190] Table 1:

[0191]

[0192] Continuing from the above, the "copying a role model" mentioned in this paper, unless explicitly specified which specific content of the role model is to be copied, at least refers to copying the formal expression of the role model. Similarly, the "dynamically loading a role model," unless explicitly specified which specific content of the role model is to be dynamically loaded, also at least refers to dynamically loading the formal expression of the role model. Furthermore, the timing of "copying a role model" and "dynamically loading a role model" in this paper is not limited to before or during the receipt of association information of the role by one software system from another software system; it is sufficient to perform these actions before generating at least one simulation result based on the role model.

[0193] Continuing from the above, Figure 2 shows the relationship between a character, a character model, and a formal expression. In this invention, a character "Character C5" is the modeling result of a character model "Character Model CM4"; the character model is a formal expression "FE" that provides observation and / or identification basis for the character's appearance and / or behavioral patterns; this formal expression has its own format and content, and the content of the formal expression of the character model is the descriptive information "DM" of the character model. In this text, unless explicitly stated whether it refers to the "format of the formal expression" or the "content of the formal expression," in the most limited technical sense, the term "formal expression" refers to both the format and content of the formal expression; furthermore, the descriptive information of the character model, in the most limited technical sense, can be interpreted as the content of the formal expression of the character model.

[0194] Continuing from the above, in a preferred embodiment, the formalized expression can be arranged and represented in the form of a structured data structure, which is a descriptive format for the specific object. A processing program can extract the formalized expression based on the declaration of each attribute in the descriptive format, extract the descriptive information of the appearance and / or behavior pattern of the specific object contained therein, and then, based on the content of the descriptive information, present the appearance and / or behavior pattern of the specific object through a part of the human-computer interface.

[0195] Continuing from the above, in another preferred embodiment, the formalized expression can also be arranged and represented in the form of an unstructured data structure. For example, an unstructured textual description of the appearance and / or behavior pattern of a specific object can be used. A processing program can input the textual description into a large language model (LLM) for analysis. After extracting the descriptive information of the appearance and / or behavior pattern from the textual description through the analysis of the large language model, the appearance and / or behavior pattern of the specific object can be presented through a part of the human-computer interface based on the content of the descriptive information.

[0196] Continuing from the above, in another preferred embodiment, the formalized expression can also be a mixture of at least one image, video, sound, and / or other non-textual multimedia content. For example, the appearance and / or behavioral patterns of a specific object can be described using at least one image, video, sound, and / or other multimedia content. A processing program can input these multimedia contents into other AI learning and deep analysis models capable of processing various non-textual content such as images, videos, and / or sounds for analysis. Through the analysis of these AI learning and deep analysis models, descriptive information about the appearance and / or behavioral patterns is extracted from the non-textual content. The implementation of extracting descriptive information from non-textual content is not limited to AI learning and deep analysis models. Taking sound as an example, Automatic Speech Recognition (ASR) technology, based on statistical models such as HMM / GMM, can convert a piece of speech information (sound) into text (string), which can be described as extracting descriptive information from non-textual content (sound). Based on the content of the extracted descriptive information, the appearance and / or behavior pattern of a specific object can be presented through a portion of the human-computer interface; or, in combination with other descriptive information arranged and represented by structured or unstructured textual narratives, the appearance and / or behavior pattern of a specific object can be presented through a portion of the human-computer interface based on the descriptive information of the textual narratives and the descriptive information extracted from the non-textual narrative content.

[0197] For ease of explanation, the various preferred embodiments described below are illustrated using a Large Language Model (LLM) capable of processing structured or unstructured textual narratives. However, other AI learning and deep analysis models capable of processing images, videos, audio, and / or other non-textual multimedia content, or various AI learning and deep analysis models that mix textual and non-textual content, are also applicable to the various implementation concepts of this invention and will not be elaborated upon here.

[0198] Continuing from the above, in another preferred embodiment, the formally expressed content can also be arranged and represented in a mixed form of structured and unstructured data structures. That is, for a specific object, certain appearance and / or behavioral pattern features can be arranged and represented in the form of structured data structures, while certain appearance and / or behavioral pattern features can be arranged and represented in the form of unstructured data structures. A processing program can process the formally expressed content using the processing methods corresponding to the structured / unstructured data structures described above.

[0199] Continuing from the above, in another preferred embodiment, the formalized expression can also be arranged and represented in a piece of program code, becoming part of the program code. The program code contains feature description information of the appearance and / or behavior pattern of the specific object. The execution steps of the appearance structure and behavior pattern action changes in the program code are like a script, and also a description of the character model. The program code also contains a driver program to perform at least one structural and / or at least one action change for the specific object. Thus, when a processor executes the program code, the program code can present the appearance and / or behavior pattern of the specific object through a part of the components in a human-computer interface based on the content of the description information.

[0200] Continuing from the above, in a preferred embodiment, the formalized content in the software system can exist in the software system in different forms. The different forms may include at least a program file, a script file, a setting, a parameter, an implementation of a structure or class, and / or any data package (e.g., an HTTP Request) that allows the software system to obtain the formalized content, but are not limited thereto.

[0201] Continuing from the above, the simulation program for a specific object (a role) within a human-computer interface includes a program that "represents the characteristics of the appearance and / or behavioral patterns of a specific object through a human-computer interface based on a formalized expression." This program can be described as a program that models (or "models") the role based on the role model within the human-computer interface, or it can be described as a program that models the role based on the formalized expression of the role model and presents the modeling result through the human-computer interface. However, the roles, role models, role simulation, arrangement, expression, and representation forms and styles of formalized expressions, as well as the implementation of modeling a role based on a role model, described in this article are not limited to the above. Those skilled in the art can make any equivalent design changes according to actual application requirements.

[0202] The "at least one structure and / or at least one action" described herein refers to the structure and / or action presented by the components described herein; wherein, the structure refers to the external display structure of the components, that is, the external display structure including hardware input / output interfaces, software input / output interfaces, graphical user interfaces, and / or any interface used for human-computer interaction and information exchange; and the action refers, on the one hand, to the action of inputting, outputting and / or processing images, sounds, pictures, text and / or any electronic signals through the components, and on the other hand, to a series of changes including the external display structure.

[0203] Continuing from the above, in a preferred embodiment, taking a robotic dog as an example, when the robotic dog simulates a pet dog, its overall components include at least one input / output interface, namely, different external display structures such as eyes, feet, mouth, and tail. These external display structures can have different variations. Adjustments to eye brightness, tail height, and foot bending angle can all be considered variations of the external display structures. A series of variations in the external display structures can represent an action. For example, a series of variations in eye brightness can represent blinking, a series of variations in tail height can represent wagging the tail, and a series of variations in foot bending angle can represent sitting. In addition, some actions can be achieved without variations in the external display structures, such as emitting a bark through a speaker inside the mouth. Although the mouth does not need to undergo any external display structure changes such as opening, emitting a bark can represent and perform the action of barking.

[0204] Continuing from the above, in another preferred embodiment, taking a smart assistant as an example, the smart assistant, in the form of an application (App), can appear as a virtual character on a graphical user interface (GUI) (also known as a software input / output interface) on a computer window screen. Its external display structure may include clothing, skin color, facial features, etc. These external display structures on the GUI can undergo single structural changes, such as an instantaneous change in skin color; a series of facial feature changes can present and execute expressions of joy, anger, sorrow, and happiness. For the GUI, these facial feature actions are formed by a series of structural changes in a portion of the display area. In another preferred embodiment, the smart assistant, through function calls within an application programming interface (API), sends requests to the operating system or other applications, or performs instruction calculations or operations to process data. This can be considered a type of action that can be presented and executed without changing the external display structure of the virtual character. However, the implementation of at least one structure and / or at least one action of the components described herein is not limited to the above, and those skilled in the art can make any equivalent design changes according to actual application requirements.

[0205] The "simulation result" described herein can be a response message output by a character simulation processing program based on a character model after receiving associated information from a character. The content of this response message may include at least one notification event, at least one updated status, and / or at least one control request based on the appearance and / or behavioral pattern characteristics of a character. The at least one control request may include a request for a change to at least one structure within a component of a human-computer interface and / or a request to execute at least one action. The appearance characteristics include shape, color, voice, structure, or any static characteristic that can be observed and / or identified by human senses; the behavioral pattern characteristics include communication, speaking, command processing, command operation, or any dynamic characteristic that can be observed and / or identified by human senses. However, the implementation of the simulation result described herein is not limited to the above.

[0206] The term "modeling" as used herein refers to the process of creating and generating a character based on descriptive information about its appearance and / or behavioral patterns. In a preferred embodiment, the appearance and / or behavioral patterns of the specific character can be defined by a character model; for example, generating a character on a graphical user interface based on descriptive information about a person, or generating artificial intelligence (AI) on a neural network platform based on the parameters of a neural network. However, the embodiments described herein are not limited to the above.

[0207] Continuing from the above, in this paper, the "simulation result" can be considered as the request, event, status, and / or response information output by a processing program of a role simulation after processing an input set of related information. The simulation result can also be considered as the related information of that role. In this invention, the simulation result can also be input into another processing program of another role simulation, making it the related information of that other role. Furthermore, another request, event, status, and / or response information output by that other role can also be input into that role, becoming another set of related information for that role.

[0208] Continuing from the above, in a human-computer interface, the simulation program for a character can include, in addition to the program that models (or "models") the character based on a character model within the human-computer interface, a program that generates at least one simulation result based on the character model. That is, a program that "receives external requests, events, states, and / or response information through different input interfaces, inputs this information to a processing program, and after the processing program determines at least one appropriate behavioral response, transforms at least one control request for the character based on the characteristic description of the appearance and / or behavioral patterns of a character model." The input interfaces can include hardware input interfaces in the human-computer interface (e.g., cameras, microphones, network signal connectors, etc.) or software input interfaces provided by the software system simulating the character (e.g., application programming interfaces, graphical user interfaces, etc.). These input interfaces can be used to receive scene events and / or scene states generated or occurring from the outside world (e.g., the virtual world and / or physical world described herein).

[0209] Continuing on the above, in a preferred embodiment, the processing program may include a logic operation program, a setting, a type of neural network, an expert system, and / or any combination thereof, but is not limited thereto; the at least one control request includes a request for change of at least one structure in the part and / or a request for execution of at least one action, and the at least one control request may be considered a preferred embodiment of the simulation results described herein.

[0210] The "behavioral response" described herein refers to the execution result displayed after executing at least one driving instruction generated based on the content of a simulation result on a software system. The simulation result includes requests for changes to at least one structure within a component of a human-machine interface and / or requests for the execution of at least one action. The at least one driving instruction is directly or indirectly triggered based on the request for changes to the at least one structure and / or the request for the execution of the at least one action. The at least one driving instruction triggers the change in the at least one structure and / or the execution of the at least one action. The at least one driving instruction may include, but is not limited to, a function call instruction, a request submission instruction, and / or a driving instruction for a hardware component or a software component.

[0211] As described above, the behavioral response can be understood as reflecting the simulated result of the character by driving the at least one structure and / or the at least one action. That is, the execution of the behavioral response represents the reflection of the simulated result. For example, the behavioral response may include at least changing the character's appearance, changing the voice, and / or emitting sounds, transmitting information, generating dialog windows, calling application programming interfaces (APIs), executing transactions, or performing calculations or operations based on the character's behavioral patterns. However, the implementation of the behavioral response described herein is not limited to the above.

[0212] Continuing from the above, in a human-computer interface, the simulation program for a character can include, in addition to the program that models (or "models") the character based on a character model in the human-computer interface, and the program that generates at least one simulation result based on the character model, the program that drives at least one behavioral response based on at least one simulation result of a character. That is, the program that "generates at least one corresponding driving instruction based on at least one control request contained in at least one simulation result of a character, thereby driving at least one structure and / or at least one action of the human-computer interface".

[0213] As described above, in any human-machine interface (HMI) of any machine and / or any software system, a program that "models (or "models") a character based on a character model," a program that "generates at least one simulation result based on a character's model," and / or a program that "drives at least one behavioral response based on at least one simulation result of a character" can all be considered as a simulation of a character within a HMI. Since predefined processing programs can be deployed on different machines and / or different software systems, simulation results can be generated on any machine and / or any software system. The control requests contained in the generated simulation results can also be sent to any other machine and / or other software system, allowing these character simulation programs to be implemented on the same or different machines, software systems, and / or HMIs. However, the simulation programs for a character described herein, as well as the implementation methods and forms for generating and driving corresponding simulation results and behavioral responses, are not limited to the above. Those skilled in the art can make any equivalent modifications based on actual application requirements.

[0214] Figure 3A illustrates a conceptual diagram of a machine and / or software system simulating the operation of a role. This may include the following procedures:

[0215] Program S1: Model (or model) a character 5 based on a character model 4; that is, based on a formalized expression (character model 4), represent the appearance and / or behavioral patterns of a specific object (character 5) through a human-computer interface.

[0216] Program S2: Generate at least one simulation result R7 based on the role model 4; that is, receive external requests, events, status and / or response information E6 through different input interfaces, input these information to a processing program, and after the processing program determines at least one appropriate behavioral response A8, transform at least one control request for the role 5 based on the feature description of the appearance and / or behavioral pattern of the role model 4.

[0217] Program S3: Drive the at least one behavioral response A8 based on the at least one simulation result R7; that is, generate at least one corresponding driving instruction based on the at least one control request contained in the at least one simulation result R7 of the role 5, thereby driving at least one structure and / or at least one action of the human-machine interface.

[0218] Figure 3B shows a preferred embodiment of "modeling (or modeling) a character based on a character model" corresponding to Figure 3A. Machine 1 is a computing device running a software system 2, and is a computing device capable of simulating the appearance and / or behavioral patterns of a character. In this preferred embodiment, the possible forms of machine 1 include at least a robot dog 11, a music bear 12, or a game console 13. Machine 1 models the character based on a character model, that is, it models the character based on a "formal expression that can provide observation and / or identification basis for the appearance and / or behavioral patterns of a specific object" (character model). When the machine 1 is a robot dog 11, the simulated character is a pet dog 51. The machine 1 models the pet dog 51 on its human-computer interface based on the character model 41 of the pet dog 51. When the machine is a music bear 12, the simulated character is a bear 52. The machine 1 models the bear 52 on its human-computer interface based on the character model 42 of the bear 52. However, when the machine 1 is a game console 13, the software system 2 running on it is a game software. The game software can construct a workspace 3, which is a video game scene 31 displayed on a monitor screen. The video game scene 31 is a graphical user interface generated by the game software and output to the monitor screen through the output interface of the machine 1. In the video game scene 31, the simulated character of the game software on the screen is a player 53. The game software models the player 53 on the graphical user interface based on the character model 43 of the player 53.

[0219] Continuing from the above, character models 41, 42, and 43 are descriptive information for corresponding characters 51, 52, and 53. They are all represented in the form of unstructured data structures and are formal expressions of the appearance and / or behavioral characteristics of their corresponding characters 51, 52, and 53. That is, the format of this formal expression can be described as an unstructured data structure, and the content of this formal expression can be described as a string of plain text descriptions. Taking the robot dog 11 as an example, in the content of the character model 41, the formal expression of the appearance characteristics of the pet dog 51 includes at least "the dog is a small dog, 35 cm tall, 40 cm long, with black ears and tail, white body, and a 15 cm tail." These appearance characteristics can be specifically reflected in the mechanical design of the robot dog 11. The formal expression of the behavior pattern characteristics of the pet dog 51 includes at least "when wagging its tail, the tail will oscillate left and right." The tail of the robot dog 11 can be designed as a mechanical tail that can be driven to oscillate left and right by electronic signals. The control of the electronic signals is mapped to one of the output interfaces of the mechanical tail as a drive command, so that the software system running in the robot dog 11 can trigger the execution of the drive command to drive the mechanical tail to perform the swaying action. Furthermore, taking Music Bear 12 as an example, the formal expression of the bear 52's appearance characteristics in the character model 42 includes at least "the bear is a polar bear, 15 cm tall, with blue ears, nose, and paws, a white body, a musical symbol on its chest, and a sitting posture." These appearance characteristics can be specifically reflected in the structural design of Music Bear 11. Similarly, taking the player modeled in the game scene 31 within the game software of the game console 13 as an example, the formal expression of the player 53's appearance characteristics in the character model 43 includes at least "male, 170 cm tall, wearing blue clothes, and a crown." These appearance characteristics can be specifically reflected in the character design of player 53 in the game scene 31. The formal expression of player 53's behavioral characteristics includes at least "when jumping, both legs bend and leave the ground," and the jumping action of player 53 in the game scene 31 can be... The animation is designed as a series of static images. In the video game scene 31, the animation shows a jumping action with both feet bent and off the ground. The driver for this jumping action is implemented in a function and packaged into an application programming interface (API). In this way, calling the function through the application programming interface can serve as a driving instruction, enabling the game software running on the game console 13 to trigger the driving instruction, that is, to call the function, and drive the player 53 to perform the jumping action in the video game scene 31.

[0220] As mentioned above, the "control request" referred to in this article includes a request to execute at least one driving instruction, or any request that has a certain meaning, that is, its content can be recognized and transformed by a software system, thereby triggering a request to execute a driving instruction.

[0221] Continuing from the above, in a preferred embodiment, the execution request may be contained in the control request itself, that is, the control request includes the triggering of the at least one driving instruction. In other words, the control request itself includes a call to at least one function of at least one application programming interface (API), the submission of at least one request (e.g., an HTTP request), or the driving of at least one hardware component or software component.

[0222] Continuing from the above, in a preferred embodiment, the meaningful request may be generated according to a communication protocol, and its content may be a number, code, and / or a tag. For example, the game software may define a jump action for the player as number 00001, code ACTION 1, and tag "#JUMP". When the user presses the jump button on the remote control, the remote control may send a request with the content 00001, ACTION 1, and / or "#JUMP" to the game software. When the game software receives the request, it can recognize that the purpose of the request is to execute the player's jump action, and thus can convert the request into a driving command that can trigger the execution of the jump action, causing the player's character to jump on the screen.

[0223] Continuing from the above, the "driving instructions" described herein include any instructions for changing an appearance structure and / or executing an action within the machine, software system, and / or workspace to which the character belongs, based on a simulation of the character's appearance and / or behavioral characteristics. The changes in appearance structure within the machine, software system, and / or workspace to which the character belongs include at least changes in shape, color, voice, construction, or any static feature observable and / or recognizable by human senses. The execution of actions within the machine, software system, and / or workspace includes at least information transmission, voice transmission, instruction calculation, instruction operation, or the execution of any dynamic feature observable and / or recognizable by human senses, such as opening a window, popping up a dialog box, sending a message, speaking, calculating a navigation path, checking the weather, or purchasing goods. In a preferred embodiment, within the software system, the logical operations required for the execution of different actions can be implemented by corresponding functions and packaged into corresponding application programming interfaces (APIs). Calling the corresponding function through the API serves as the driving instruction for executing the corresponding action. However, the implementation methods and forms of control requests, execution requests and drive instructions described herein are not limited to the above.

[0224] Continuing from the above, in a preferred embodiment, the robot dog 11 has LED lights in its eyes with adjustable brightness, a mechanical tail that can swing left and right, and a character model 41 that may include at least one rule arranged in a structured data structure and stored in a file or database in the robot dog 11's storage device. The software system running on the robot dog 11 (e.g., a robot dog's operating system) includes a processing program developed in the Java programming language. After loading the contents of the file or database, this processing program can, based on the description of the at least one rule, realize the appearance and / or behavioral characteristics of the pet dog 51 through the human-machine interface of the robot dog 11. For example, the content of the at least one rule may include:

[0225] {

[0226] “mode-1”:

[0227] {

[0228] "tail-swing-angle": 30,

[0229] “eye-brightness”: “100%”

[0230] },

[0231] “mode-2”:

[0232] {

[0233] "tail-swing-angle":15,

[0234] “eye-brightness”: “50%”

[0235] }

[0236] }

[0237] Continuing from the above, at least one rule is a formal expression declared and defined by a JSON structured data structure. This formal expression is in JSON format, and its content is a JSON Object. This JSON Object describes two different patterns. The data structure of each pattern declares rules for some appearance and / or behavioral pattern characteristics, such as eye brightness and tail-swing angle. The set values ​​for brightness and tail-swing angle define these appearance and / or behavioral pattern characteristics, thus completing the rule description of appearance and / or behavioral pattern characteristics under different patterns. As seen in the example above, in pattern 1, the eye brightness is 100% full brightness, and the tail-swing angle is 30 degrees; while in pattern 2, the eye brightness is 50% half brightness, and the tail-swing angle is 15 degrees. When the software system of the robot dog 11 is running, the processing program loads a file or database containing the at least one rule from the storage device, and after reading the content of the at least one rule, it can display the appearance and / or behavioral pattern characteristics of the character according to the rules corresponding to each mode.

[0238] Continuing from the above, in a preferred embodiment, the character model 41 may include a script, stored in a file or database in the storage device of the robot dog 11. This script, through the definition of at least one rule, provides a more detailed description of the appearance and / or behavioral pattern characteristics, thereby allowing for more detailed control over the display of these characteristics. For example, for mode 1 in the above embodiment, the script content may be provided as follows:

[0239] EYES BRIGHTNESS

[0240] [00:00 - 00:01] 50%

[0241] [00:01 - 00:02] 75%

[0242] [00:02 - 00:03] 100%

[0243] TAIL SWING ANGLE

[0244] [00:00 - 00:01]10

[0245] [00:01 - 00:02]20

[0246] [00:02 - 00:03]30

[0247] Continuing from the above, although the script content is not represented using a JSON structured data structure, it still possesses a certain analyzable structure, making it a structured script. The information revealed in the title, "EYES BRIGHTNESS" and "TAIL SWING ANGLE," allows the software system to recognize that the script content contains detailed controls on eye brightness and the swaying angle of the mechanical tail. In the eye brightness (EYES BRIGHTNESS) script, the left side of each line represents the time interval in seconds, which can be considered a meaningful key. The right side is the value of that key. The key and value represent a meaningful rule. For example, [00:00 - 00:01] 50% means that from second 0 to second 1, the eye brightness is adjusted to 50%. [00:01 - 00:02] 75% means that from second 1 to second 2, it is adjusted to 75%. The script content for BRIGHTNESS allows for detailed adjustments to the eye brightness, enabling a gradual brightening motion through precise control. Similarly, in the script content for the mechanical tail sway angle, [00:00 - 00:01] 10 indicates a sway angle of 10 degrees from second 0 to second 1, while [00:01 - 00:02] 20 indicates a sway angle of 20 degrees from second 1 to second 2, achieving a gradually increasing sway amplitude through precise control.

[0248] As mentioned above, when the software system of the robot dog 11 is running, the processor loads the file containing the script, and can analyze the content of the script according to the structure of the script file, including the definition of the title and the rule definition of each key value. After extracting the information of each key value, it can control the operation performance of mode 1 in detail by changing a series of changes in the appearance display structure when displaying the appearance and behavior mode characteristics of mode 1.

[0249] Continuing on the above, in a preferred embodiment, the script can also be directly represented in a piece of program code and integrated into the handler. By using program code to write at least one rule defined by the script into the program code, it can be considered a programmatic script. For example, the handler in the software system of the robot dog 11 may include the following program code:

[0250] public void adjustEyesBrightness(Dog aDog) {

[0251] new Thread() {

[0252] public void run() {

[0253] try{

[0254] / / Adjust the eye brightness to 50%

[0255] aDog.setEyesBrightness(0.5f);

[0256] / / The thread sleeps for 1 second, that is, in the first second, maintaining brightness at 50%.

[0257] Thread.sleep(1000l);

[0258] / / After one second, adjust the eye brightness to 75%.

[0259] aDog.setEyesBrightness(0.75f);

[0260] / / The thread sleeps for 1 second, that is, the second second, maintaining 75% brightness.

[0261] Thread.sleep(1000l);

[0262] / / After two seconds, adjust the eye brightness to 100%.

[0263] aDog.setEyesBrightness(1f);

[0264] …

[0265] } catch(Throwable t) {}

[0266] }

[0267] }

[0268] }

[0269] Continuing on the above, in a preferred embodiment, a programmed script may also be included in another processor within the software system of the robot dog 11. This processor can invoke the function adjustEyesBrightness through an inter-process communication interface, such as a remote method invocation (RMI) technology.

[0270] Continuing from the above, when the program needs to control the brightness of the pet dog's eyes to be fully bright, it can call the function `adjustEyesBrightness`. The program code of this function contains rules for detailed control of eye brightness. It can be seen that the rules of a script can also be represented in the form of program code, becoming part of the program code contained in one program or another.

[0271] Continuing from the above, in object-oriented software systems, a formal expression can also be represented through a data model (e.g., an object's class). For example, in the video game scenario 31, player 53 can be described in the game software of the game console 13 using an object entity generated by the following data model. Designed according to this data model, the data members of this object entity, referring to Table 2, include integer types for height and weight, and string types for gender. Its member function includes a jump function, indicating that the player can perform a jump action. The software developer can then generate an object entity of this data model for player 53 in the game software and set the characteristics of player 53, such as height 170 cm and gender, as shown in Figure 3B, to the corresponding data members. In the technical field of the Java programming language, a data model can be implemented as a Java class. That is, the syntax of the Java programming language can be considered the format of this formal expression, and the program code used for this Java class can be considered the content of this formal expression, representing the character's appearance and / or behavioral patterns in the program code; however, the implementation of the data model is not limited to this example. In the program code of this Java class, other required appearance and / or behavioral pattern characteristics can be added to the data model by adding data members and / or member functions, so that a complete description of player 53 can be given through the object entity. In this way, the program can grasp the characteristics of player 53's appearance and / or behavioral patterns through the object entity.

[0272] Table 2:

[0273]

[0274] Continuing from the above, the mechanical design of the robot dog 11 and the music bear 12 allows them to display the animal appearance features of the pet dog 51 and the bear 52. Similarly, the player 53 displayed on the graphical user interface of the video game scene 31 also displays the character appearance features of player 53. However, not all computing devices can represent the appearance features of characters on the human-computer interface. For example, in real life, a robot vacuum cleaner might be designed as a disc, lacking human-like appearance features. However, it can actually use other input / output interfaces in the human-computer interface, as well as the app installed on the user's phone, to simulate the behavioral patterns of a character.

[0275] Continuing from the above, in a preferred embodiment, a robotic vacuum cleaner can provide a corresponding App that a user can install on a mobile phone. When the App is executed on the mobile phone, a graphical user interface (GUI) can be displayed on the phone's screen, allowing the user to interact with the robotic vacuum cleaner through this GUI. Although the GUI is not displayed on the robotic vacuum cleaner itself, it can still be considered an extended human-machine interface for the robotic vacuum cleaner. In a preferred embodiment, the robotic vacuum cleaner may have a behavioral pattern feature, that is, when the App receives the user's instruction to "go back to charge," the robotic vacuum cleaner can issue a drive command to drive its speaker to say in a human voice, "I'm going home to charge." Through this behavioral response, a human-like persona is simulated, allowing the user to observe and recognize that the robotic vacuum cleaner provides services as a cleaning assistant. Furthermore, some devices may only simulate the appearance of a character, failing to represent behavioral patterns. For example, while the Music Bear 12 simulates the Bear 52 character in its design, its overall function may simply be a music player, failing to utilize speakers and microphones to interact with the user using the Bear 52's voice. Therefore, character simulation refers to the simulation of both static appearance features and / or dynamic behavioral patterns.

[0276] Continuing from the above, in neural networks, a formal expression can also be represented through the weights and biases of each neuron. These weights and biases can be considered the parameters of each neuron, the structure of the neuron can be considered the format of the formal expression, and the parameters on each neuron can be considered the content of the formal expression. For example, in the field of neural network technology, a neural network can be trained using a generative adversarial network (GAN) to generate a dog bark sound upon receiving a string instruction (e.g., the word "bark"). The characteristics of the dog bark sound are embodied in each neuron of this neural network, represented by weights and biases. In any software system or program, by allocating the same number of neurons to another neural network with the same architecture as this neural network, and copying the weights and biases of all neurons in this neural network to those neurons in the other neural network, the other neural network can also have the ability to generate dog barks. The neural network can be considered a character model, and the weights and biases distributed among the neurons in the neural network can be considered a descriptive information of this character model. Although neurons in a neural network have their own structure, the weights and biases scattered throughout the neurons in the neural network can also be regarded as unstructured data in this paper.

[0277] Continuing from the above, in an expert system, a formal expression can be represented by at least one rule. The format of this formal expression can be considered the knowledge representation of the expert system, while the content of this formal expression can be considered at least one rule in the expert system's rule base (or knowledge base). Through this at least one rule, the appearance and / or behavioral pattern characteristics of a role can be described and provided to the expert system's rule base. Among these, the representation of the patent system is the format of the expert system's knowledge base, which covers various forms of expression and structures of knowledge in the expert system.

[0278] Continuing from the above, regardless of whether it is represented by structured and / or unstructured data structures, or by weights and biases in a neural network-like system, any data structure, data model, programming language syntax, or any combination thereof that can describe a role can be the format of the formal expression described in this invention, that is, the form of representation and expression of formal expression. However, the representation and expression methods of formal expression, as well as the implementation of the content of formal expression described herein, are not limited to the above.

[0279] Continuing from the above, in a preferred embodiment, the deployment architecture of a processing program may include a type of neural network, and the descriptive information of a role model (i.e., the formal expression, i.e., the parameters of each neuron) may be embodied in the neuron architecture of the type of neural network, that is, the role model may be part of the processing program; or, the deployment architecture of the processing program may include an expert system, and the descriptive information of the role model may be embodied in a part of the rules of the expert system, making the role model part of the processing program; or, the processing program may include a logic operation program, and the descriptive information of the role model may exist in a part of the program file, script file, settings, parameters, and / or an implementation of a structure or class of the logic operation program, making the role model part of the processing program; or, the architecture of the processing program may include a type of neural network, an expert system, a logic operation program, and / or any combination thereof, and different parts of the descriptive information of the role model may exist separately in the type of neural network, the expert system, or the logic operation program, jointly constructing a complete role model. In summary, the character model and the processing program can be integrated into a single processing unit, or they can be divided into two separate processing units (e.g., the character model exists in another processing program). The two separate processing units can be integrated through an application programming interface (API), but this is not a limitation.

[0280] Continuing from the above, Figure 3C shows a preferred embodiment of the "program for generating at least one simulation result based on a character model" and the "program for driving at least one behavioral response based on at least one simulation result of a character" corresponding to Figure 3A, and Figure 3B is also referenced. In this embodiment, the pet dog 51 in Figure 3C and the pet dog 51 in Figure 3B are the same or equivalent characters, simulated on a computing device (robot dog 11), and the robot dog operating system 21 is the software system running on the robot dog 11; the player 53 in Figure 3C and the player 53 in Figure 3B are the same or equivalent characters, simulated in a video game scene 31 generated by the computing device (game console 13), and the video game scene 31 in Figure 3C and the video game scene 31 in Figure 3B are the same or equivalent workspace, and the game software 23 is the software system running on the game console 13; the user 8 in Figure 3C is the owner of the pet dog 51 and also the controller of the player 53.

[0281] Continuing from the above, in a preferred embodiment, the user 8 gives a "quiet" voice instruction to the robot dog 11 by speaking. A microphone may be provided at the ear of the robot dog 11 as an input interface for receiving external sounds. After the robot dog operating system 21 receives "quiet" audio data from the input interface, it can regard "the audio data" as a state produced in the physical world. "Detecting and receiving the sound state" can be regarded as an event triggered from the physical world. Then, the event and state information are passed as parameters to a predefined processing program 61 developed in the Java programming language. The processing program 61 determines the at least one appropriate behavioral response and converts it into at least one control request for the pet dog 51. In a preferred embodiment, the at least one behavioral response is "sit down", and the at least one control request is to drive the four limbs (hardware components) of the robot dog 11 to make it squat on the ground. In another preferred embodiment, the at least one behavioral response may also include "stop making sounds", and the at least one control request may also include stopping the drive of the speaker (hardware component) of the robot dog 11 to make it squat quietly on the ground.

[0282] As mentioned above, the at least one behavioral response refers to the execution result displayed after executing at least one drive instruction generated based on the content of a simulation result on the robot dog operating system 21. It can also be said that the at least one behavioral response is the execution result displayed after triggering the execution of "at least one simulation result generated based on the role model 41 of the pet dog 51". To achieve a behavioral response of squatting and / or ceasing barking upon hearing silence, in a preferred embodiment, in addition to the specifications shown in Figure 3B, the character model 41 can additionally have a rule arranged in a JSON structured data structure in a file or database in the storage device of the robot dog 11. This rule can be used to set a new mode, which can be named "mode-quiet" (quiet mode). In this mode, the squatting angle of "limb-bending-ange" (limb bending angle) can be set, and / or the "speaker-barking" (speaker barking) can be turned off. Alternatively, a script can be provided in a file or database in the storage device to provide more detailed control over the squatting action of bending the limbs by having different angles corresponding to different numbers of seconds during the squatting process. Furthermore, the output interface design of the robot dog 11 incorporates mechanical limbs that can be bent using electronic signals and / or a speaker that can be turned on / off using electronic signals. These electronic signals are mapped to drive commands for the output interfaces of the mechanical limbs and speaker. This allows the robot dog operating system 21 running within the robot dog 11 to trigger and execute these drive commands, causing the mechanical limbs to bend and / or the speaker to turn off. Thus, based on the character model description and according to "mode-quiet" and / or the corresponding script, the robot dog operating system 21 can generate commands to drive the limbs and speaker. These commands, triggered and executed within the robot dog operating system 21, cause the robot dog 11's mechanical limbs to crouch and / or the speaker to stop emitting sound, thereby simulating the pet dog 51 exhibiting the behavioral response of "sitting and / or stopping barking." However, the implementation methods and forms of behavioral responses, role models, driving commands and / or simulation results are not limited to the above, and those skilled in the art can make any equivalent design changes according to actual application needs.

[0283] Continuing on, process 61 and process 63 are predefined in the robot dog operating system 21 and game software 23, respectively. In a preferred embodiment, the implementation of the character models of the pet dog 51 and the player 53 in the deployment architecture of process 61 and process 63 may include, but is not limited to: (i) the process 61 and / or the process 63 contains an inference unit. The inference unit can be a type of neural network trained through deep learning and based on an inference model. After receiving information such as requests, events, states, and / or response information, the inference model can infer the appearance and behavior of the simulated character based on the input information. / or what the change in behavior pattern is, then based on the result inferred by the inference model, the corresponding control request can be output. Finally, the execution result of the control request on the robot dog operating system 21 and game software 23 and their associated computing device can be said to be a behavioral response determined by the corresponding character simulation based on these input information, or the control request can be said to be the simulation result of the behavioral response determined by these input information; (ii) the processing program 61 and / or the processing program 63 contain an expert system, in which the rule base (or knowledge base) of the expert system stores the mapping rules between "different requests, events, states and / or response information" and "the appearance and / or behavior patterns that they should exhibit". After the received request, event, status and / or response information is input into the expert system, the changes in appearance and / or behavior patterns of the simulated character can be deduced based on the rule base of the expert system. Then, based on the results deduced by the expert system, the corresponding control request can be output. Finally, the execution result of the control request on the robot dog operating system 21 and game software 23 and their associated computing device can be said to be a behavioral response determined by the corresponding character simulation based on the input information. It can also be said that the control request is the simulation result of the behavioral response determined by the input information. (iii) The processing program 61 and / or the processing program 63 contain a logic operation program. In the implementation of the logic operation program, it has the logical operation capability to deduce the changes in appearance and / or behavior patterns of the simulated character based on the input request, event, status and / or response information. Thus, after inputting the received requests, events, status and / or response information into the logic operation program, the logic operation program can deduce the changes in appearance and / or behavior patterns that the simulated character should exhibit. Then, based on the deduced results, the corresponding control request can be output. Finally, the execution result of the control request on the robot dog operating system 21 and game software 23 and their associated computing devices can be said to be a behavioral response determined by the corresponding character simulation based on the input information. In other words, the control request is the simulation result of the behavioral response determined by the input information.

[0284] Continuing on the above, in a preferred embodiment, process 61 and / or process 63 are predefined processes. The predefinition can refer to a role model within the deployment architecture of a process, meaning that the role model is pre-set, trained, or implemented in the deployment architecture of the process before the software system leaves the factory. However, the role model can also be adjusted based on user usage after the system is manufactured and made available to the user. For example, a neural network can learn different behavioral responses based on the user's daily usage after manufacturing, or the user can rearrange and set the rule base of an expert system according to their own needs. Alternatively, the logic operation program can provide a configuration file for the user to arrange and set the rules for its logic operation processing (e.g., changing the script content and / or parameter content in the configuration file). However, this is not a limitation; those skilled in the art can make any equivalent design changes based on actual application requirements.

[0285] Continuing from the above, in a preferred embodiment, the role model contained in the deployment architecture and / or program code of the process 61 and the process 63 may be implemented by the inference unit, expert system, logic operation program, or any combination thereof, but is not limited thereto. Any software component, software agent, software engine, software service, software platform, application program, and / or any program that can simulate and deduce the appearance and / or behavioral pattern changes that a role should exhibit based on the content of input requests, events, status and / or response information, etc., may be an implementation method and implementation form of the process 61 and the process 63, but is not limited thereto. Those skilled in the art can make any equivalent design changes according to actual application needs.

[0286] Continuing from the above, in a preferred embodiment, the role model in the processing program 61 has an inference unit. This inference unit is a type of neural network that has been learned and trained based on an inference model that maps different audio data to different behavioral patterns. That is, during the learning and training process, audio of various instructions is input into this type of neural network, and the output of this type of neural network is a decision on a change in appearance and / or behavior pattern. The decision on the change in appearance and / or behavior pattern referred to here is to decide which of the aforementioned modes "mode-1", "mode-2", and "mode-quiet" should be adopted. By using a large amount of audio data of "quiet" and other instructions recorded in different environments, and using the spectrogram data of these audio data to pre-train this type of neural network, this type of neural network can correctly make an inference on which mode (e.g., mode-1, mode-2, or mode-quiet) to adopt after receiving audio data of various instructions. For example, after inputting the audio data of "quiet" and its spectrogram into this type of neural network, it can output that the mode to be executed is "mode-quiet". In this way, when the robot dog operating system 21 receives "quiet" audio data from the microphone input interface, it obtains its spectrogram data through spectrum conversion, and then inputs the spectrogram data into the processing program 61. After inference by the inference unit, it can be deduced that the mode to be exhibited is "mode-quiet". Then, the processing program 61 can generate a control request containing instructions to drive the limbs and the horn based on the settings of the limb bending angle and horn barking in the "mode-quiet" mode. Then, the control request is output to the robot dog operating system 21, and the robot dog operating system 21 can execute the drive instructions contained in the control request, so that the pet dog 51 exhibits the behavioral response of "sitting and / or stopping barking". Regarding the training of this type of neural network, its inferred output does not necessarily need to be a direct selection of different modes. It can also use an intermediate value as a representation, such as an emotion value as its output. Then, a predefined mapping table is used to map the emotion value to different modes. For example, when training this type of neural network, after receiving the spectrogram data of the audio "go for a walk", it infers and outputs the emotion value representing happiness (e.g., the emotion value representing happiness is 1); after receiving the spectrogram data of the audio "quiet", it infers and outputs the emotion value representing calmness (e.g., the emotion value representing calmness is 2). In the predefined mapping table, the emotion value 1 is mapped to the mode "mode-1", and the emotion value 2 is mapped to the behavior mode "mode-quiet". In this way, after obtaining the inferred emotion value, the mapping table can be queried, and then the corresponding control request can be generated and output to the robot dog operating system 21 according to the mode corresponding to the emotion value.In this embodiment, the parameters of the neural network, the rules in the mapping table, and the definitions of the behavioral patterns (mode-1, mode-quiet) can all be considered as part of the pet dog 51 character model. The learning and training methods of the neural network are mostly well-known techniques and will not be elaborated upon herein, nor are they limited thereto. Those skilled in the art can make any equivalent modifications based on actual application needs.

[0287] Continuing from the above, in a preferred embodiment, the role model in the processing program 61 includes a speech recognition program and an expert system. When the robot dog operating system 21 receives "quiet" audio data from the microphone input interface, it can input the audio data and the event of detecting and receiving the audio data into the processing program 61. The processing program 61 can know from the event information that the audio data is a sound received from the physical world through the microphone, indicating that the audio data may be the owner's voice instruction, and thus indicating that processing is required. Then, the processing program 61 can input the audio data into the speech recognition program. First, the speech recognition program performs spectrum conversion on the audio data. After obtaining the spectrogram data of the "quiet" audio, it compares the spectrogram data with the pre-stored data in the database. The spectrogram data features of the commands are compared. One of the spectrogram data features of these different commands includes spectrogram data for "quiet". The expert system's rule base can pre-establish logical operation rules for matching different spectrogram data features. For example, the expert system's rule base could contain a rule that loads "mode-quiet" when the spectrogram data features of the audio data input from the microphone match the spectrogram data features for "quiet" in the database. According to this rule, the expert system can deduce the "mode-quiet" result for the "quiet" voice instruction. Then, based on the "mode-quiet" setting, the processing program 61 can output the corresponding control request to the robot dog's operating system 21. In this way, the processing program 61 can generate a simulated behavioral response to the "quiet" voice instruction given by the owner in the physical world. The database of spectrogram data features can be pre-stored in the robot dog's storage device when the robot operating system 21 is manufactured. In another preferred embodiment, the processing program 61 can also be implemented as a single speech recognition program. That is, the logical judgment rule in the expert system that "which spectrogram data feature matches which instruction corresponds to which mode" is directly implemented in a function of the speech recognition program. In this way, after the speech recognition program completes the comparison of spectrogram data features, the speech recognition program inputs the comparison result into the function. In the logical operation of the function, it can be determined that when the input spectrogram data features match the spectrogram data features of "quiet", the mode "mode-quiet" should be executed, and a corresponding control request is generated to the robot dog operating system 21 to exhibit the behavior of crouching. In this embodiment, the rules in the expert system, the logical operation in the speech recognition program, and the definitions of these behavioral modes (mode-1, mode-quiet) can all be regarded as part of the pet dog 51 role model.

[0288] Continuing from the above, the control request is not limited to being generated by the processor 61, but can also be generated by the robot dog operating system 21. In this way, the processor 61 does not need to output the control request to the robot dog operating system 21, but instead notifies the robot dog operating system 21 of the result of inferring or deriving the mode "mode-quiet". The robot dog operating system 21 then loads "mode-quiet" and, based on the settings of "mode-quiet", generates and executes the corresponding control request. In this implementation, the role model in the processor 61 is only responsible for determining the behavioral response, and the simulation result is generated by the robot dog operating system 21 based on the behavioral response. However, the role model in the processor 61 is not limited to the selection of modes (e.g., mode-1, mode-2, mode-quiet), but can also include the selection of different scripts. This allows for detailed control of actions in various modes based on the content of the script when a control request is generated.

[0289] Continuing from the above, in a preferred embodiment, the game software 23 is a software system developed using the Java object-oriented programming language. The processor 63 is a program within the game software 23 used to control one of the player 53 object entities in the video game scene 31. When the game software 23 receives a user command to "cross the obstacle" from its input interface (e.g., an input interface connected to the remote control via infrared), the game software 23 can input this "cross the obstacle" user command to the processor 63. Upon receiving the user command, the processor 23 can convert it into multiple control requests to complete the user command. For example, crossing an obstacle must include at least two control requests: "jump" and "forward." These control requests are then used to call member functions of the object entity to drive the player 53 in the video game scene 31 to jump forward. In this embodiment, both the object entity and the logic operation program in the processor 23 that converts control requests can be considered part of the player 53 character model.

[0290] Continuing from the above, in a preferred embodiment, the object entity representing the player 53 in the game software 23 system, and the robot dog operating system 21, can design a number to form a protocol for control requests containing multiple drive instructions. For example, in the game software 23, in addition to forming an application programming interface (API) by opening different member functions for the handler 63 to call, the object entity can also design a member function named process(String aActionTag). In the implementation of this function, when the input parameter is the string "#jump-ahead" 73, the function can execute the drive instruction to add forward to the jump of the player 53. In this way, the logical operations in the handler 63 do not require detailed understanding of the API related to all the driving instructions of the object entity. Its control request can be simplified to just containing a string "#jump-ahead" 73. This string itself represents the control request and also represents the instruction that can wrap multiple driving instructions. Calling the process function of the object entity and passing in this string can realize the action of driving the player 53 to jump forward. Similarly, for the robot dog operating system 21 to complete the crouching action, in addition to changing the angle of the limbs according to the mode "mode-quiet", it may also include loading the script of the limb bending action to control the details of the bending process. This includes the detailed control of the multiple driving instructions to be completed at different time periods. Accordingly, the robot dog operating system 21 can design a number "#sit" 71 for the limb bending change of the mode "mode-quiet" to form a protocol. That is to say, "#sit" represents the driving instruction to execute the limb bending change and / or limb bending action script of "mode-quiet". In this way, the control request output by the processing program 61 to the robot dog operating system 21 can be simplified into a string "#sit" 71. When the robot dog operating system 21 receives the control request, it can complete the control of bending the limbs according to the instructions of "#sit" 71 to show the squatting action.

[0291] Continuing from the above, the sound (quiet) received by the robot dog 11 from its microphone input interface, and the user command (cross the obstacle) received by the game software 23 from its infrared input interface, can both be considered as external states. Through these embodiments, it can be seen that the external world includes both the physical world and the virtual world. The source of the sound (quiet) is the user's voice instruction in the physical world; it is originally a sound from the physical world, received by the robot dog 11 through the microphone input interface. The source of the user command (cross the obstacle) is a digital command composed of electronic signals in the virtual world; it is originally a command from the virtual world. External states are usually accompanied by an event, which is transmitted to the input interface simultaneously. For example, when the sound (quiet) state is transmitted, it is accompanied by the event of "sound received"; when the user command (cross the obstacle) state is transmitted, it is accompanied by the event of "user submitting command on remote control". However, in another preferred embodiment, the input interface can also respond to the received event or state by simulating the behavior of the character. For example, the robot dog 11 can be defined and described in its character model to bark when it hears an unexpected sound. So when the robot dog 11 suddenly receives any audio (state) from the microphone input interface in a quiet environment, it can respond to the event of "receiving sound" (a sudden event in the physical scene) without having to pay attention to the content of the audio. Alternatively, the game software 23 can define and describe the character model of the player 53 to display a sweating icon when the time limit of the game level is approaching. In this way, the object entity representing the player 53 in the game software 23 system can be implemented as a time state (time state in the virtual scene) that monitors the remaining time of the game level in real time. When the remaining time is closer to zero, the sweating icon is displayed. As can be seen from the above embodiments, the "external requests, events, statuses and / or response information" mentioned herein actually includes both "physical world requests, events, statuses and / or response information" and "virtual world requests, events, statuses and / or response information." Furthermore, the "external requests, events, statuses and / or response information" are not only requests, events, statuses and / or response information that directly act on the character in the form of instructions, directives or commands, but also include various requests, events, statuses and / or response information that the character receives from the physical or virtual scene that occurs within the scene.

[0292] The "associated information" referred to herein refers to information generated through the simulation of a role in a machine and / or a software system; wherein, when the simulation of the role is represented through a human-computer interface of the machine and / or the software system, its appearance characteristics and / or behavioral pattern characteristics are represented by changes in at least one structure and / or the execution of at least one action within a component of the human-computer interface; wherein, the component includes at least one hardware input / output interface, at least one software input / output interface, at least one graphical user interface, and / or at least one interface for human-computer interaction and information exchange; the associated information includes the information transmitted, received, and / or transmitted on at least one interface within the component when the role is simulated on the machine and / or the software system. Information that can be transmitted or interacted with, such as requests, events, statuses, and / or responses transmitted, received, and / or interacted with through the at least one interface; wherein, the associated information of a role includes at least requests issued by the user to control, operate, and / or drive the role, events and / or statuses generated or occurring in the outside world, the simulation results of the role, and / or any information transmitted, received, and / or interacted with through the at least one interface based on the simulation of the role; wherein, the simulation results of the role can also be considered as the response information made by the role in response to a request, event, or status, the content of which can be at least one control request, at least one notification event, at least one status update, and / or any combination thereof generated to drive at least one behavioral response. However, the implementation of the associated information described herein is not limited to the above, and those skilled in the art can make any equivalent design changes according to actual application needs.

[0293] Continuing from the above, in a preferred embodiment, the "associated information" includes not only the information transmitted, received, and / or interacted between the user and the role on at least one interface of the aforementioned components, but also the information transmitted, received, and / or interacted between different external applications and the role through software input / output interfaces. These different applications may include "different software modules and / or processes within the same software system," "another software system on the same machine or another machine," and "different software modules and / or processes within another software system." The software input / output interfaces may include, at least, application programming interfaces (APIs) for information exchange between different applications, interfaces for inter-process communication, and / or interfaces for process calls between different applications, but are not limited to these. For example, in a workspace scenario, when a software system simulates a role, the software system can open a communication port. On this communication port, a set of RESTful APIs can be implemented based on the HTTP communication protocol. The RESTful API allows the system to receive requests, events, statuses, and / or responses from different applications. It can also be used to send back requests, events, statuses, and / or responses generated during role simulation to different applications. In another preferred embodiment, the software system can also implement a WebSocket communication interface to accept WebSocket connection requests from different applications. Through the established WebSocket connection, it can receive requests, events, statuses, and / or responses from different applications, or send requests, events, statuses, and / or responses generated during role simulation to different applications. The RESTful API and WebSocket interfaces can serve as inter-process communication interfaces between different applications within the same workspace, and can also act as interfaces for remote procedure calls to interact with other applications on another machine. However, the implementation of the software input / output interfaces described herein is not limited to the above, and those skilled in the art can make any equivalent design changes based on actual application requirements.

[0294] Figure 4 illustrates a conceptual diagram representing the associated information of a role. This associated information includes requests, events, statuses, responses, and / or any type of information transmitted, received, and / or interacted with based on the simulation of the role. Specifically, the associated information of role 5 may include requests, events, statuses, and / or responses 91 received in the scene, and requests, events, statuses, and / or responses 92 issued by the role. However, the implementation of the information transmitted, received, and / or interacted with by role 5 is not limited to requests, events, statuses, and / or responses; the requests may be represented in structured or unstructured text form, and / or in any combination of multimedia forms such as images, text, video, and audio, for example, Web representation in XML structured form. Service requests can be unstructured textual questions that can be transmitted to a chatbot, user voice commands in audio form, or HTTP requests containing any combination of text, images, videos, audio, etc., but are not limited thereto. Events include software events and hardware events, typically referring to any specific event generated within a software or hardware system to reflect externally generated or occurring scene events. These events usually trigger some form of response or processing. Events can be represented in various forms such as notifications and alerts, but are not limited thereto. Response information can contain at least one simulated result corresponding to a behavioral response. Its content can be represented by at least one control request, at least one notification event, at least one update status, and / or any combination thereof, but is not limited thereto. Status typically refers to the scene status or role update status generated or occurring externally, such as descriptive information about the specific situation of a scene, system, or role, but is not limited thereto.

[0295] Continuing from the above, in a preferred embodiment, when a software system simulates a character 5 on a machine, the software system can enable the character 5 to interact with the user 8 or the external environment through different hardware input / output interfaces, and can also implement different software input / output interfaces to enable the character 5 to interact with different applications. The software system receives requests, events, statuses, and / or responses from the user 8 or the external environment through these hardware input / output interfaces, and / or receives requests, events, statuses, and / or responses from different applications through these software input / output interfaces, as associated information for the character 5. The software system transmits this associated information (received requests, events, statuses, and / or responses 91 in the scene) to a processing program simulating the character 5. The processing program can then generate at least one simulation result corresponding to at least one behavioral response of the character 5 based on the received requests, events, statuses, and / or responses 9. The at least one simulation result may include the character 5's request, event, status, and / or response information 92.

[0296] Continuing from the above, in another preferred embodiment, the associated information of the role 5 also includes new requests, events, states, and / or responses generated in the scene based on the requests, events, states, and / or responses 92 issued by the role 5. For example, the at least one simulation result generated by the process based on the simulation of the role 5 can be at least one simulation result containing at least one request, event, state, and / or response information 92, which can be output through hardware input / output interfaces and / or software input / output interfaces. The method may include driving or executing the at least one simulation result, displaying the request, event, state, and / or response information 92 of the role 5 to the user through changes and displays of appearance and / or behavioral pattern characteristics on the human-machine interface; it may also include sending the content of the at least one simulation result to other external applications through application programming interfaces, inter-process communication, or procedure calls. Whether the user perceives the request, event, status and / or response information 92 of the role 5 through changes and displays in the human-machine interface, or an external application receives the request, event, status and / or response information 92 of the role 5, it can generate new request, event, status and / or response information in response to the request, event, status and / or response information 92 issued by the role 5, and transmit it again to the processing program of the simulated role 5 through the hardware input / output interface and / or the software input / output interface, so as to serve as new request, event, status and / or response information 91 in the scene.

[0297] As described above, the request, event, status, and / or response information 91 received through the hardware input / output interface and / or software input / output interface, and the request, event, status, and / or response information 92 generated by the processing program simulating the role 5, can all be considered implementations of the associated information. However, the implementation of the role's associated information described herein is not limited to the above, and those skilled in the art can make any equivalent modifications based on actual application requirements.

[0298] Continuing on the above, in another preferred embodiment, the request, event, status and / or response information 91 received in the scene, and the request, event, status and / or response information 92 issued by the role 5, can be transmitted, received and / or interacted with in a mixed manner through various hardware input / output interfaces and / or software input / output interfaces. For example, a character simulated on one machine can send a question request to the software system of another machine through an application programming interface (API) implemented on a communication interface. After receiving the request, the software system can: 1) output the request as sound to a user through a speaker (hardware interface), and the user's response can be received as sound by the microphone (hardware interface) on the other machine. This response, as a response, can be sent back to the software system simulating the character on the first machine through the API; or 2) display a dialog box (software interface) on the screen of the other machine to output the question as text to the user. The user can input text using a keyboard (hardware interface) and fill in the response in the dialog box. This response, as a response, can be sent back to the software system simulating the character on the first machine through the API. However, the implementation of the related information described herein through various hardware input / output interfaces, software input / output interfaces, and / or combinations thereof for transmission, reception, and / or interaction is not limited to the above. Those skilled in the art can make any equivalent design changes based on actual application requirements.

[0299] Figure 5 shows a schematic diagram illustrating the operational concept of attaching a role from one system to a role from another system, with reference to Figures 3A, 3B, and 3C. In Figure 5, the game software 23 is a software system running on a machine (i.e., game console 13), and the player 532 is a character simulated by the game software 23 in the video game scene 31. The video game scene 31 in Figure 5 is the same or equivalent workspace as the video game scenes 31 in Figures 3B and 3C. The robot dog operating system 21 in Figure 5 is another software system running on another machine (i.e., robot dog 11), and the pet dog 51 is the same or equivalent role as the pet dog 51 in Figures 3B and 3C. In this embodiment, the processing program 61 in Figure 5 and the processing program 61 in Figure 3C are the same or equivalent processing programs, and the processing program 63 in Figure 3C is the same or equivalent processing program. The processing program 63 is a program in the game software 23 that controls one of the player 532 object entities in the video game scene 31. In the various embodiments of this document, the game software 23 can be a first software system, and the game console 13 can be a first machine. When the game software 23 is a first software system and the game console 13 is a first machine, the robot dog operating system 21 is a second software system, and the robot dog 11 is a second machine. Alternatively, the robot dog operating system 21 can be a first software system, and the robot dog 11 can be a first machine. When the robot dog operating system 21 is a first software system and the robot dog 11 is a first machine, the game software 23 is a second software system, and the game console 13 is a second machine. Furthermore, the first software system and the second software system are orthogonal systems to each other, constructing an orthogonal workspace.

[0300] Continuing from the above, in Figure 5, the associated information 712 is at least one associated information of the pet dog 51; the simulation result 732 includes at least one control request, which includes a request for change of at least one structure of the player 532 and / or the game scene 31 and / or an execution request for at least one action based on the appearance characteristics and / or behavioral pattern characteristics of the pet dog 51.

[0301] As mentioned above, in Figure 5, the pet dog 51's role model contains at least one rule and / or at least one programmed script. The overall control of the pet dog 51 in the robot dog 11 system can be considered as the modeling result of the robot dog operating system 21 on the pet dog 51's role model. In addition to having at least one rule and / or at least one programmed script, the pet dog 51's role model may also include any formal expression that can provide observation and / or identification basis for the pet dog 51's appearance and / or behavior patterns. The robot dog operating system 21 can model the pet dog 51 based on the formal expression of the pet dog 51's role model and display the modeling result through the human-machine interface of the robot dog 11. Furthermore, player 532 can share the same or equivalent character model as player 53. This character model may also contain at least one rule and / or at least one procedural script. Player 532 can be considered the modeling result of the game software 23 of player 532's character model in the game scene 31. In addition to having at least one rule and / or at least one procedural script, player 532's character model may also contain any formal expression that provides observation and / or identification basis for player 532's appearance and / or behavior patterns. The game software 23 can model player 532 based on the formal expression of player 532's character model and display the modeling result through the human-computer interface generated by the game machine 13 itself and / or the game software 23. Various implementation methods for the formal expression have been provided in this document and will not be elaborated further. Those skilled in the art can make any equivalent design changes according to actual application requirements.

[0302] Continuing from the above, in a preferred embodiment, the game software 23 opens a communication interface and implements a set of RESTful APIs (Application Programming Interfaces) based on the HTTP communication protocol on this communication interface. This allows software systems on other machines to send HTTP requests containing the associated information 712 to the handler 61 through these RESTful APIs. This enables the game software 23 to receive the associated information 712 through the application programming interface and then pass it to the handler 61. Furthermore, the game software 23 also periodically sends multicast packets within its network to inform other software systems on the network of the game console 13's IP address, the port number of the communication interface, and the RESTful APIs supported by the communication interface. Within the same network, when the robot dog operating system 21 in the robot dog 11 receives the multicast packet, it can read the address, port number, and description of the RESTful API in the packet. Based on the description of the RESTful API, the robot dog operating system 21 confirms that the RESTful API is an application programming interface that it can recognize and support. Then, it can connect to the communication interface via an HTTP connection based on the address and port number to establish an information channel. Through this information channel, it sends an HTTP request containing the associated information 712 to the game software 23. The game software 23 can then receive the associated information 712 sent by the robot dog operating system 21 from the information channel.

[0303] Continuing from the above, in a preferred embodiment, after the game software 23 receives and processes the associated information 712, it can also send a response message back to the robot dog operating system 21 via an HTTP Response. The format of the HTTP Request and the HTTP Response, the HTTP communication interface, and the calling method of the RESTful API constitute the communication protocol for data transmission between the game software 23 and the robot dog operating system 21. Similarly, the robot dog operating system 21 can also open an interface based on the HTTP communication protocol to receive another HTTP Request from the game software 23 and send another HTTP Response back to the game software 23. This implementation allows two orthogonal software systems to transmit and interact with each other through mutually supported communication protocols. However, the implementation of establishing a network connection between different software systems and transmitting, receiving, and / or interacting with information through that network connection is not limited to the above. Those skilled in the art can make any equivalent modifications based on actual application requirements.

[0304] Continuing from the above, in a preferred embodiment, the pet dog 51 character model includes a first procedural script, which performs an action according to the following steps:

[0305] The pet dog 51 generates at least one piece of associated information (i.e., the associated information 712), which includes: A) a request to attach a character to the player 532 and to display the appearance and color of the character on the player 532; B) at least one state describing the appearance and / or behavioral characteristics of the character, such as the character being a pet dog and the color of its fur, and / or a dog that barks a lot; C) an event indicating that the user has authorized the character to play with him.

[0306] Generate an HTTP Request and fill the associated information 712 into the HTTP Request Body of the HTTP Request.

[0307] The HTTP Request is submitted through the RESTful API application programming interface of the game software 23, transmitting the associated information 712 to the game software 23.

[0308] Continuing from the above, in a preferred embodiment, the game software 23 and the robot dog operating system 21 have certain standard definitions for the content format of the associated and response information transmitted between them, which can be described as the communication protocol required for information interaction between the two software systems. Specifically, the associated information 712 can be arranged using a JSON structured data structure; the event can be represented by an identifier, such as PLAY_WITH_USER_AUTHORIZED indicating that the user has authorized the pet dog 51 to play with him; the request can also be represented by an identifier, such as POSSESS_PLAYER_2_AND_CHANGE_COLOR indicating a request to have the pet dog 51 possess the player 532, making the player 532 a possessed character of the pet dog 51; the at least one state can be represented by a string, such as DOG indicating that the character to possess the player 532 is a dog, WHITE indicating that the character's fur color is white, and YAPPY indicating that the character is a dog that likes to bark for no reason. Based on this content format, the associated information 712 can be represented as follows:

[0309] {

[0310] "event": "PLAY_WITH_USER_AUTHORIZED",

[0311] "request": "POSSESS_PLAYER_2_AND_CHANGE_COLOR",

[0312] “character”:

[0313] {

[0314] "type": "DOG",

[0315] “color”: “WHITE”,

[0316] “behavior”: “YAPPY”

[0317] }

[0318] }

[0319] Continuing from the above, in a preferred embodiment, the game software 23 receives the HTTP Request through the RESTful API application programming interface. After receiving the associated information 712 in the HTTP Request Body, since the format and content of the associated information 712 conform to the standard definition, both the game software 23 and the processor 63 can read and parse the meaning of the information therein.

[0320] Continuing from the above, in a preferred embodiment, the user 8 gives the robot dog 11 a voice instruction to "play a game with me" by speaking. After receiving the audio data of "play a game with me" from the microphone (hardware input interface) at the ear of the robot dog 11, the robot dog operating system 21 can regard "the audio data" as a state produced in the physical world, and "detecting and receiving the sound state" can be regarded as an event triggered from the physical world. Then, the event and state information are passed to the processing program 61 in the form of parameters. The processing program 61 determines a behavioral response through inference and deduction. For example, the processing program 61 contains a first expert system. The first expert system has a rule that, when the instruction to "play a game with me" is received, the first procedural script is executed to generate the associated information 712, and then the associated information 712 is encapsulated into an HTTP Request and sent to the game software 23. The behavior of submitting the associated information 712 to the game software 23 in the form of an HTTP Request is the behavior of the pet dog 51 after receiving the instruction from the user 8. Therefore, it can be said to be the behavior of the pet dog 51, and the submission of the HTTP Request can be said to be a control request.

[0321] Continuing from the above, in a preferred embodiment, the audio data of "play games with me" can be directly input into the processing program 61. A speech recognition program included in the processing program 61 performs spectrum conversion on the audio data to obtain spectrogram data. This spectrogram data is then compared with the features of spectrogram data of different instructions pre-stored in a database. Furthermore, logical operation rules for matching different spectrogram data features can be pre-established in the rule base of the first expert system. For example, the rule base of the first expert system contains a rule that if the instruction "play games with me" is received, the first procedural script will be executed. According to this rule, after receiving the voice instruction from user 8, the speech recognition program, through spectrum conversion and spectrogram comparison, confirms that the voice instruction is "play games with me" and inputs it into the first expert system. The first expert system can then identify and locate the procedural script to be executed (i.e., the first procedural script) based on the instruction "play games with me". In this embodiment, the rules in the first expert system and the first procedural script can be regarded as part of the pet dog 51 character model.

[0322] Continuing from the above, in a preferred embodiment, after the game software 23 receives the HTTP Request from the RESTful API application programming interface (software input interface), it can receive the association information 712 of the pet dog 51 from the HTTP Request Body of the HTTP Request, and then pass the association information 712 to the processing program 63 as a parameter.

[0323] Continuing from the above, in a preferred embodiment, player 532 is a second player. The character model of player 532 includes a second procedural script, which, upon receiving the content of the associated information 712, will execute an action according to the following steps:

[0324] Read the character information from the associated information 712.

[0325] Change the color of player 532's clothing to the color indicated by the color information in the character information (i.e., white).

[0326] Stop the game software 23 from controlling the player 532.

[0327] Continuing from the above, in a preferred embodiment, the game software 23 includes another processing program. This other processing program can control the player 532 based on the current execution state of the game scene 31, allowing the player 532 to automatically participate in the game in the game scene 31 without the user 8's intervention. This other processing program can be considered a player agent program driving the player 532. The player agent program also provides an application programming interface (API) that provides a function named "stop." In its implementation, this function provides the ability to pause the player agent program's control over the player 532, thus pausing the game software 23's control over the player 532. Therefore, when the processing program 63 calls the "stop" function, the game software 23's control over the player 532 can be paused.

[0328] Continuing from the above, in a preferred embodiment, when the game software 23 receives the HTTP Request, it extracts the associated information 712 and passes it to the processing program 63. Upon receiving the associated information 712, the processing program 63 can determine at least one behavioral response through inference and deduction. For example, the processing program 63 includes a second expert system with a rule that executes the second procedural script if the event is PLAY_WITH_USER_AUTHORIZED and the request is POSSESS_PLAYER_2_AND_CHANGE_COLOR. That is, the processing program 63 first reads and extracts the event and request information from the associated information 712. Next, this information is passed to the second expert system. The second expert system infers based on the information content of the event and request, and infers that the related information 712 should be processed by the second procedural script. Then, the processing program 63 can execute the second procedural script and pass the related information 712 to the second procedural script.

[0329] Continuing from the above, in the execution step of the second procedural script, the second procedural script will issue a control request via a function call, that is, call the function named "stop," thereby stopping the game software 23's control over the player 532. Furthermore, the second procedural script will also issue another control request, driving a change in the appearance of a component of the graphical user interface of the game scene 31 (the display area of ​​the player 532), specifically changing the color of the player 532's clothing to white in the display area rendered on the graphical user interface. In this embodiment, the rules in the second expert system and the second procedural script can be considered as part of the player 532's character model.

[0330] As mentioned above, this graphical user interface is a human-computer interface provided by the game software 23. The behavior of changing the appearance color of player 532 can be considered as the first behavioral response of the game software 23 based on the associated information 712, which drives a part of the graphical user interface. Since the first behavioral response and the requested function of the associated information 712 are mutually responsive and consistent, that is, the clothing color (an appearance structure) of the display block (this part of the component) of player 532 is changed according to the request. The request represented in the associated information 712 is actually the simulation result output by the simulation of the pet dog 51 based on the pet dog 51 character model (which requires changing the color). Therefore, although the first behavioral response acts on player 532, and the control request that drives this part of the component to change the color is included in the simulation result 732, what is actually reflected can be considered as a simulation result of the pet dog 51. Changing the appearance color of clothing on the graphical user interface can be considered as a simulation of the pet dog 51 character. That is, the execution of the first behavioral response can be considered as a mapping of the simulation result of the pet dog 51 character.

[0331] Continuing from the above, stopping the player 532 from being automatically controlled in the game software 23 can also be described as a second behavioral response made by the game software 23 based on the associated information 712 and a component of the application programming interface (the stop function) that drives the player agent program. When the automated control function is stopped, the player 532 in the graphical user interface stops acting. This second behavioral response represents a change in behavior pattern, meaning that the player 532 is no longer controlled by the game software 23 itself. Since the request in the associated information 712 only indicates a desire to possess, but does not request to stop automated control, the second behavioral response and the requested function of the associated information 712 are not consistent. Therefore, the second behavioral response is mainly a simulation result generated by the player 532 based on the player 532's own character model. The second behavioral response acts on the player 532, and the control request that drives this component (the stop function) to stop being automatically controlled is also included in the simulation result 732. It maps to a simulation result of the player 532. The action of stopping automated control in the game scene can be said to be based on the simulation made on the player 532 character. That is, the execution of the second behavioral response is a mapping of the simulation result 732 of the player 532 character.

[0332] Continuing from the above, in another preferred embodiment, the game software 23 does not support the function of changing the clothing color of the player 532. In this case, the behavioral response generated in response to the association information 712 can only include the second behavioral response. In another preferred embodiment, the game software 23 does not have any application programming interface that can be used to stop the automated control of the player 532. In this case, the behavioral response generated in response to the association information 712 can only include the first behavioral response. Therefore, it can be seen that the implementable behavioral responses will differ depending on the functions supported by the software system. In summary, a behavioral response is a simulation result of a character and / or another character, generated by driving at least one structure and / or at least one action.

[0333] Continuing from the above, in a preferred embodiment, the game scene 31 is a graphical user interface rendered by the game software 23 on a television screen, that is, the graphical user interface is a human-computer interface generated by the game software 23 and extended to another machine (television) for presentation; in another preferred embodiment, the game console 13 itself may have a screen, then the graphical user interface generated by the game software 23 can be directly displayed on the screen. In this case, it means that the graphical user interface and the screen of the game console 13 together constitute a human-computer interface; furthermore, in another preferred embodiment, when the game console 13 has no screen to visually display the game scene 31, the character's behavior and reaction can also be expressed through sound interaction via other hardware input / output interfaces provided by the game console 13, such as microphones and speakers.

[0334] Continuing from the above, in a preferred embodiment, some descriptive information (formal expression) of the character model of player 532 can be represented by the weights and biases of a type of neural network. This type of neural network is a learned and trained neural network that, through a familiar "generative adversarial network" training method, can automatically generate audio data of a dog barking when it receives the "#dog-barking" string instruction. In this embodiment, the character model in player 532 includes a third procedural script, which, upon receiving the "#dog-barking" string instruction, performs an action according to the following steps:

[0335] Passing the string "#dog-barking" into this type of neural network generates audio data of a dog barking sound.

[0336] The audio data of the dog barking is output through a speaker on the game console 13.

[0337] Continuing from the above, the second expert system included in the processing program 63 has a rule that if the "type" in the associated information 712 is "DOG" (indicating a dog) and the "behavior" is "YAPPY" (indicating a barking dog), then the string instruction "#dog-barking" is passed to the third procedural script and executed. The third procedural script then passes the string instruction "#dog-barking" to the neural network to generate dog bark music data, and then issues a control command to the loudspeaker to drive the loudspeaker to output the dog bark music data. The barking behavior can be considered a third behavioral response driven by the game software 23 based on the associated information 712, which triggers a component (speaker) within the human-computer interface of the game console 13. Since the request in the associated information 712 only indicates possession but does not explicitly request barking, this third behavioral response is inconsistent with the function requested by the associated information 712. Therefore, this third behavioral response is also a simulation result generated for the player 532 based on the player's character model. This third behavioral response acts on the player 532, and the control request to drive the speaker to bark is included in the simulation result 732. This third behavioral response maps to a simulation result of the player 532. The player 532's barking action after being possessed can be considered a simulation based on the player 532's own behavioral pattern; that is, the execution of this third behavioral response is a mapping of the player 532's simulation result 732. In this embodiment, the rules in the second expert system and the third procedural script can be considered as part of the player 532's character model.

[0338] Continuing from the above, the first behavioral response, the second behavioral response, and the third behavioral response can be selectively driven by the processing program 63. It can drive only one behavioral response or any combination thereof. Therefore, what is mapped can be considered the simulation result of the pet dog 51 and / or the player 532 in response to the associated information 712; that is, the execution of at least one behavioral response is a mapping of the simulation result of the pet dog 51 and / or the player 532. In this text, the so-called mapping refers to a corresponding relationship between "behavioral response" and "simulation result." A simulation result can be a control request or a combination of multiple control requests. After the simulation result is processed, a corresponding behavioral response can be generated. Therefore, it can be said that there is a corresponding relationship between "behavioral response" and "simulation result." In other words, the simulation result of a character can actually map a behavioral response, and it can also be said that the behavioral response of a character also maps the simulation result of a character. These two statements represent a corresponding relationship. The simulation result 732 may include at least one control request, which includes a request for change of at least one structure (e.g., changing clothing color, changing vocalization) and / or a request for execution of at least one action (e.g., stopping automated control, barking) based on at least one appearance feature and / or at least one behavioral pattern feature (e.g., body color, vocalization, automated control, excessive barking) of the pet dog 51 and / or the player 532. The at least one appearance feature includes shape, color, vocalization, structure, or any static feature that can be observed and / or identified by human senses. The at least one behavioral pattern feature includes communication, speech, command processing, command operation, or any dynamic feature that can be observed and / or identified by human senses. Human senses include, but are not limited to, human senses such as eyes, ears, nose, tongue, skin, and / or brain consciousness.

[0339] Continuing from the above, in a preferred embodiment, the RESTful API provided by the game software 23 is a set of application programming interfaces (APIs) conforming to RESTful Level 3. The overall design of the API is fully implemented in accordance with the constraints of HATEOAS (Hypermedia as the Engine of Application State). Following the constraints of HATEOAS, when a REST client interacts with the game software 23 providing this API, the hypermedia information responded by the game software 23 dynamically provides information such as the accessible resources included in the game software 23, resource descriptions, and the corresponding URL paths. This means that the REST client almost does not need to know in advance how to interact with the resources in the game software 23, because the hypermedia information provides all the necessary instructions. In the design of this API, various types of information and tools are considered as resources, and all resources are mapped to different URL paths, meaning each resource has an independent URL. Submitting HTTP requests such as GET, POST, PUT, and DELETE to a resource's URL allows for the generation, reading, modification, and deletion of that resource. Furthermore, a "list of all resources" can also be considered a resource. By submitting an HTTP GET request to the URL corresponding to that list, one can obtain resource descriptions of all important information and / or tools within the game software, as well as the URLs corresponding to that information and / or tools. After obtaining the URLs of all information and / or tools, to access, store, or manipulate a particular resource, one only needs to submit the corresponding HTTP Request to that resource's URL.

[0340] Continuing from the above, in a preferred embodiment, before the robot dog operating system 21 receives the voice instruction from the user 8 and outputs associated information to the game software 23, it can first perform a step, namely, through the application programming interface, to obtain the URLs corresponding to all resources in the game software 23, such as a resource of a "weather display window" (a tool) and a resource of a "user player avatar" (a piece of information).

[0341] Following this, the robot dog operating system 21 can then send an HTTP POST request to the web resource of the weather display window. Upon receiving the HTTP Request, the game software 23 can then drive the resource of the weather display window to perform the "display current weather" operation, that is, generate a window on the graphical user interface and display the current weather information in that window. Alternatively, the robot dog operating system 21 can then send an HTTP PUT request to the user's character model, thereby changing the character model of the player 53 on the graphical user interface.

[0342] Continuing from the above, with the increasingly mature development of Large Language Models (LLM), when the robot dog operating system 21 receives a voice instruction from the user 8, it can convert the voice instruction into a string representation using Automatic Speech Recognition (ASR) technology. Then, the string instruction, along with the resource description information of all resources of the game software 23, is input into a trained Large Language Model (e.g., ChatGPT, Gemini, etc.), and the operating system queries the Large Language Model to determine which resource the instruction represented by the string should access. Through the inference and deduction of the Large Language Model, the operating system finds the resource that matches the user 8's instruction. The Large Language Model can exist on other external machines, and the robot dog operating system can establish a connection to these other external machines and make API calls to them through an information channel. For example, the resource description information for the "weather display window" is "can be used to display the current weather", and the user's instruction is "help me display the current weather". The resource name, the resource description information, and the instruction can be put into a text template to form a text question. Through the API of the large language model, the text question can be passed into the large language model, and the large language model can find the weather display window resource that can fulfill the user's instruction.

[0343] Following on from the above, the following is an example of this text template:

[0344] Which of the following web resources can use "[user instructions]"?

[0345] A, "[First Resource Name]" — "[First Resource Description Information]"

[0346] B, "[Second Resource Name]" — "[Second Resource Description Information]"

[0347] …

[0348] Following on the above, the following are the parameters that should be applied to the text template in this embodiment:

[0349] [User Instruction] = Please show me the current weather

[0350] [First Resource Name] = Weather Display Window

[0351] [Second Resource Name] = Stock Trading Tools

[0352] [First resource description information] = Can be used to display the current weather.

[0353] [Second Resource Description Information] = Can be used to trade stocks

[0354] Following on from the above, the following is an example of this text question, that is, the text question formed by fitting the text parameters into the text template:

[0355] Which of the following web resources can "help me display the current weather"?

[0356] A, "Weather Display Window" -- "Can be used to display the current weather".

[0357] B, "Stock Trading Instruments" -- "Can be used to trade stocks"

[0358] Continuing from the above, the pet dog 51 character model contains a fourth procedural script. After receiving a string instruction from the user and various resource description information, this fourth procedural script performs an action according to the following steps:

[0359] By inserting a user instruction and various resource descriptions as parameters into the above text template, a text question is generated.

[0360] By using the API of the large language model, the text problem is passed into the large language model, and the inference of the large language model is used to find resources that can be used to execute the user instruction.

[0361] An HTTP Request is generated that sends a request to the URL corresponding to the resource. This HTTP Request can be considered as associated information about the pet dog 51. The HTTP Method of this HTTP Request—whether it should be HTTP GET, HTTP POST, HTTP PUT, or HTTP DELETE—can be determined based on the resource description information. For example, if the resource description information is represented by a structured data structure containing an attribute named HTTP METHOD, the content of which is GET, POST, PUT, or DELETE, analyzing the resource description information according to the definition of this structured data structure will determine which HTTP Method should be used to generate the HTTP Request.

[0362] Submit the HTTP Request to the URL path of the resource, and send the associated information to the game software 23.

[0363] Continuing from the above, when user 8 gives a voice instruction to robot dog 11, saying "Show me the current weather," this instruction can first be converted into a string instruction using automatic speech recognition technology, and then passed to processing program 61 as a parameter. Through inference and deduction by processing program 61, a behavioral response is determined. For example, the first expert system contained in the processing program 61 has a rule that when a user instruction is received, if there is no corresponding procedural script in the first expert system to process the user instruction, the fourth procedural script is executed. With the help of the large language model, it is determined that the "weather display window" is a resource that can be used to execute the string instruction, thereby generating the association information (HTTP Request), and then directly submitting the association information to the URL path of the resource, and sending the association information to the game software 23. The behavior of sending the association information to the game software 23 is the behavior of the pet dog 51 after receiving the instruction from the user 8 (show me the current weather), so it can be said to be the behavior of the pet dog 51. The association information (HTTP Request) itself is a request, and the submission of the request can be said to be a control request transformed from the behavior, representing a simulated result output by the pet dog 51 after receiving the sound instruction. In this embodiment, the rules in the first expert system and the fourth procedural script can be regarded as part of the pet dog 51 role model.

[0364] Continuing from the above, in a preferred embodiment, after the game software 23 receives the HTTP Request, since the URL directly represents the resource (i.e., the weather display window), and the HTTP Request also directly represents access to the resource (generating a weather display window), there is no need for processing by the handler 63. The game software 23 can directly launch the resource, that is, generate a window in a portion of the display area on the graphical user interface, and display the current weather information in the window. Querying and displaying the current weather information can be considered a transaction execution. If the game software 23 includes various tools capable of executing different types of transactions, its design can be modified accordingly, allowing the pet dog 51 to dynamically extend new functions using the resources within the game software 23. That is, the pet dog 51 can dynamically handle new user instructions, dynamically support new behavioral responses, and directly extend these responses into the game scene 31. For example, when the pet dog 51 leaves the factory, it cannot query stock-related information. By making equal changes to the above implementation method, as long as the game software 23 has a stock query tool and the stock query tool is an accessible resource, and with the auxiliary inference of the large language model, the pet dog 51 can query stock information through the stock query tool in the game software 23. The equal implementation method can also be used for buying and selling goods through commodity trading, etc., but is not limited to this.

[0365] Continuing from the above, since the game software 23 can complete the transaction of displaying the current weather information based on or in response to the associated information without going through the processing program 63, and generate a corresponding fourth behavioral response in the game scene 31 (driving a part of the display block to change, generating a window in it to display the current weather information), it means that even if the game software 23 does not include the processing program 63, the player 532, the player 532's character model, or even the pet dog 51 character and its character model in the game scene, the game software 23 can still exhibit the fourth behavioral response in the game scene 31 by driving at least one structure and / or at least one action in some of the components. The fourth behavioral response acts within game scene 31. The control request that drives the game scene to display the current weather is a simulation result of the pet dog 51. In other words, the fourth behavioral response maps to a simulation result of the pet dog 51. Upon hearing the user say "Help me display the current weather," the pet dog obediently assists the user in performing the transaction (displaying the weather). This can be considered a simulation based on the behavior pattern of the pet dog 51. That is, the execution of the fourth behavioral response is a mapping of the simulation result of the pet dog 51 character.

[0366] Continuing from the above, in various preferred embodiments, the behavioral response can be implemented in different ways. For example: First, by making a partial structural change to the display area rendering a character on a graphical user interface, a behavioral response that changes the character's appearance can be generated; second, by changing the character's audio (the character's voice spectrum can be considered a structure), a behavioral response that changes the character's voice can be generated; third, by calling a function in an application programming interface (API) to execute a transaction and / or a specific instruction, a behavioral response that calls the API, executes a transaction, and / or executes a specific instruction can be generated; fourth, under specific events or states, Using a character's voice or name, a message is sent by speaking through a loudspeaker, establishing a communication connection, or generating a dialog window on a graphical user interface, thereby generating behavioral responses for that character to emit sound, transmit messages, or generate a dialog window. In this document, the implementation of a character's behavioral responses includes at least one type of driving action based on a change request of the at least one structure and / or an execution request of the at least one action. This document includes various implementation methods, but is not limited to the various implementation methods included herein. Those skilled in the art can make any equivalent design changes according to actual application requirements.

[0367] Figure 6 shows a schematic diagram illustrating the operational concept of a system generating an avatar, and Figures 3A, 3B, 3C, and 5 are also referenced. In this system, the game software 23 in Figure 6 and the game software 23 in Figure 5 are the same or equivalent software system; the game console 13 and the game console 13 in Figure 5 are the same or equivalent machine; the video game scene 31 and the video game scene 31 in Figure 5 are the same or equivalent workspace; the robot dog operating system 21 in Figure 6 and the robot dog operating system 21 in Figure 5 are the same or equivalent software system; the pet dog 51 and the pet dog 51 in Figure 5 are the same or equivalent character; and the processing program 61 and the processing program 61 in Figure 5 are the same or equivalent processing program.

[0368] Continuing from the above, in Figure 6, the association information 713 is at least one piece of association information for the pet dog 51. Similar to association information 712, association information 713 is arranged according to the JSON structured data structure; its content also includes an event where the user authorizes the pet dog 51 to play with him / her; it also includes at least one state of the pet dog 51 character; the request is also represented by an identifier, but the attached request is different. This identifier is CREATE_NEW_ROLE, indicating that a new character is created for the pet dog 51 character in game scene 31. Therefore, association information 713 can be represented as follows:

[0369] {

[0370] "event": "PLAY_WITH_USER_AUTHORIZED",

[0371] "request": "CREATE_NEW_ROLE",

[0372] “character”:

[0373] {

[0374] "type": "DOG",

[0375] “color”: “WHITE”,

[0376] “behavior”: “YAPPY”

[0377] }

[0378] }

[0379] Continuing from the above, in a preferred embodiment, the character object (a JSON object) in the associated information 713 contains a description of the appearance and / or behavioral patterns of the pet dog 51. This can be considered a descriptive information of the pet dog 51's character model, or a formal expression of the pet dog 51's character model, arranged in a structured data structure. From this descriptive information, it can be seen that the pet dog 51 is a white, barking puppy.

[0380] Continuing from the above, in a preferred embodiment, the graphical user interface of the game scene 31 originally only contains players 53 and 532, without any other characters. The process 64 and the process 63 can be different processes; the process 63 is a process for simulating a specific player character, while the process 64 can support the automatic generation of a completely new character. When the game software 23 receives the association information 713, if the request in the association information 713 is "CREATE_NEW_ROLE", it is handed over to the process 64 for processing.

[0381] Continuing from the above, in a preferred embodiment, the processing program 64 may include a database containing images of common animals of different kinds and colors (e.g., dogs, cats, birds, etc.), as well as pre-recorded sounds of these different kinds of animals. The processing program 64 includes program code, the logical operation program of which can be used to analyze the data structure of the association information 713. First, the processing program 64 uses the program code to analyze and extract information on type, color, and behavior from the association information 713.

[0382] Continuing from the above, the program code itself contains a formalized expression of an avatar character. That is, the program code contains a fifth procedural script implemented in the form of program code. This fifth procedural script contains at least one rule to simulate the avatar character. In this embodiment, the character model of the avatar character exists directly in the form of program code in the processing program 64. Among them, the at least one rule includes: 1) After receiving the information description of type and color, confirming that the type is a puppy and the color is white, selecting a white dog icon from the database and issuing a control request to drive the graphic user interface to display the white dog icon in a part of the display block; 2) After receiving the information description of behavior, confirming that the behavior is YAPPY (barking excessively), issuing a control request to drive a timer to emit events at irregular intervals. The program code listens for these irregularly emitted events. When the program code receives these events, it retrieves the pre-recorded dog bark from the database and drives the speaker to emit the dog bark. Accordingly, upon receiving the associated information 713, the associated information 713 is passed to the program code as a parameter and the fifth procedural script is executed. The resulting control requests are the simulation results 733 for a new character, which can drive a behavioral response. That is, in the game scene 31, a new character, namely an avatar dog 533, is generated for the pet dog 51. Here, the avatar dog 533 can be regarded as an avatar of the pet dog 51 in the game scene 31, or an avatar character, which originally did not exist in the graphical user interface. In any display area, the presentation of the avatar dog 533 on the graphical user interface is automatically generated based on the description information of the pet dog 51 (the character object in the association information 713). For the pet dog 51, the appearance and / or behavior pattern of the avatar does not necessarily need to be the same as the appearance and / or behavior pattern of the pet dog 51 itself. The pet dog 51 can generate avatars with different appearances and / or different behavior patterns for itself in the game scene 31 through description information with different appearance features and / or behavior pattern features. In this embodiment, the description information of the pet dog 51 (the character object in the association information 713) and the fifth procedural script can be regarded as part of the character model of the avatar dog 533.

[0383] Continuing from the above, in the associated information 713, the description information of the pet dog 51, namely the character object, includes a characteristic description of the appearance (color: WHITE) and behavior pattern (behavior: YAPPY, prone to barking) of the avatar dog 533. In fact, if the character object does not contain a characteristic description of the behavior pattern, the avatar dog 533 can still be automatically generated according to the described implementation method, the only difference being that it does not need to emit barking sounds from time to time; if the character object does not contain a characteristic description of the appearance, a new character will still appear in the game scene 31. This new character, as an avatar of the pet dog 51, although not appearing in the part of the graphical user interface display block, can output dog barking sounds through a part of the human-computer interface (speaker) in the form of sound. Even if the pre-recorded dog barking sound is different from the barking sound emitted by the pet dog 51 on the robot dog 11 device, it allows the user 8 to observe and recognize that there is a new character, and according to its instructions, enters the game scene 31 as the avatar of the pet dog 51. In summary, the description information of the pet dog character model 51 may include a description of the appearance and / or behavior pattern of an avatar, and the avatar enters the game scene 31.

[0384] Continuing from the above, in a preferred embodiment, the description information of the pet dog 51 does not necessarily need to be a JSON Object (character object); it can also be a plain text description of an unstructured data structure (e.g., the character model 41 in Figure 3B). That is, the value of "character" in the associated information 713 is a string of plain text description, which is the character model 41. In this case, the fifth procedural script can actually pass this string into a type of neural network trained by a generative adversarial network, which will then generate the required illustration of the avatar dog 533 based on the description of the string, and then display it on the graphical user interface.

[0385] Continuing from the above, in another preferred embodiment, the pet dog 51 does not necessarily need to enter the game scene 31 as an avatar; it can also enter the game scene 31 as its own character (i.e., the pet dog 51 itself). This extends the simulation of its own character into the game scene 31, that is, it maps itself into the game scene 31, creating a mapped character within the game scene 31. For example, the game software 23 includes an application platform that has the ability to analyze the association information 713 and provides an architecture capable of adding plug-ins to Java programs. This architecture defines a standard interface, allowing any Java program that implements this standard interface during development to be dynamically loaded into the application platform as a plug-in during runtime via Java ClassLoader technology. The standard interface defines a function that can receive association information from parameters, which the application platform can use to pass the association information to the loaded Java program for processing. In the Java technology field, the technical implementation of dynamically loading plug-in programs using ClassLoader is a common technique, and therefore will not be elaborated upon here. Handlers 63 and 64 can be considered as predefined Java programs pre-mounted on the application platform.

[0386] Continuing from the above, the robot dog operating system 21 may include a Java plugin implemented according to the standard interface. This Java plugin includes: 1) a setting for the application platform to read, which has an attribute named "supported_event" with the content "CREATE_NEW_ROLE", indicating that the Java plugin can handle the "CREATE_NEW_ROLE" event; 2) a sound file, namely the barking of the pet dog 51; and 3) a Java class implemented in the Java programming language, whose program code implements the standard interface and the function. Within the function's program code, a sixth procedural script is implemented, containing a rule that, upon obtaining the behavior information description in the associated information 713 and identifying the content as "YAPPY," a timer is driven to periodically emit events, and these events are listened for. Upon receiving these events, the sound file is retrieved, and the speaker is driven to play the sound file. In game scene 31, the dog 51 makes its own barking, which can be described as simulating the dog 51's barking behavior in game scene 31.

[0387] Continuing on the above, the robot dog operating system 21 can transmit the Java plugin to the game software 23 via a connection. Upon receiving the plugin, the game software 23 can deploy it to a designated location (e.g., a designated folder) on the application platform for dynamically loading plugins. Then, when the game software 23 receives the association information 713, it can pass it to the application platform. The application platform analyzes the association information 713, extracts the event information (i.e., "CREATE_NEW_ROLE"), and then iterates through all plugins in the designated location. By comparing the event information with the "supported_event" attribute set by each plugin, it can identify the Java plugin that can handle the association information 713, dynamically load the Java class using a Java ClassLoader, and generate a Java object of that Java class. Next, the association information 713 can be passed to the Java object as a parameter through the standard interface and the function (calling the function), so that the Java object can execute the sixth procedural script based on the association information 713, simulate the behavior pattern of the pet dog 51 in the game scene 31, and produce a behavioral response corresponding to the association information 713.

[0388] Continuing from the above, according to the described implementation, even if the character object in the associated information 713 does not contain a description of appearance features, the role of the pet dog 51 can still be simulated in the game scene 31, as if the pet dog 51 has entered the game scene 31. That is, the pet dog 51 maps itself into the game scene 31, so that there is a role it has mapped in the game scene 31. According to this implementation, the sixth procedural script can be considered as part of the role model of the pet dog 51. The method of dynamically loading the Java plug-in from the robot dog operating system 21 into the game software 23 can also be considered as allowing the role model that originally did not exist in the game software 23 to be dynamically loaded from the robot dog operating system 21 into the game software 23 during execution.

[0389] Continuing from the above, for the game software 23, the Java plugin is a dynamically loaded handler. Unlike the predefined handlers in the game software 23 (e.g., handlers 63 and 64), this Java plugin does not originally need to exist in the game software 23. This Java plugin can be considered a self-contained component, completely encapsulating the pet dog 51's character model within its own program code. The application platform only needs to pass in the associated information through the standard interface and the function to drive it to independently complete the work and tasks required for character simulation. The mechanism of dynamically loading the character model allows a character in a specific scene to enter and run in another specific scene across regions, networks, systems, and workspaces.

[0390] Continuing from the above, in a preferred embodiment, by utilizing the implementation mechanism of dynamically loading character models, the pet dog 51 can also enter the game scene 31 as an avatar, so that a character in a scene, whether as an avatar or the character it maps to, can enter another scene across regions, networks, and systems.

[0391] Continuing from the above, for example, in the robot operating system 21, the implementation of the Java plugin can be slightly modified. That is, in the settings of the Java plugin, the content of the "supported_event" attribute is still "CREATE_NEW_ROLE", but the sound file included is the howl of a wolf, and additionally includes wolves of various colors. In the Java class (implementing the standard interface) implemented by its Java program, the sixth procedural script contains the wolf as the default type of avatar.

[0392] Continuing from the above, when the Java plugin is dynamically loaded into the game software 23, the information description of color is obtained from the association information 713, and the specified color is identified. The corresponding wolf icon can be selected and displayed on the graphical user interface of the game software 23. The information description of behavior is obtained from the association information 713, and the content is identified as YAPPY (likes to bark), and the speaker can be driven to play the wolf's howl at irregular intervals. Before sending the association information 713, the robot dog operating system 21 first sends the Java plugin to the game software 23 for deployment. After sending the association information 713 to the game software 23, the application platform can dynamically load the Java plugin, driving it to automatically generate a new character (wolf) in the game scene 31, serving as the avatar of the pet dog 51 in that scene. Following this implementation method, after modifying the sixth procedural script, the sixth procedural script can be considered the character model of the avatar. Its formal expression format is the syntax of the Java programming language, and its formal expression content is the program code, which can also be considered the descriptive information of the avatar's character model. In summary, in one system, the descriptive information of an avatar's character model can be provided by another system.

[0393] As mentioned above, the mechanism for dynamically loading character models can include a variety of different implementations, such as:

[0394] (i) This can be achieved using neural network-like techniques. In a software system, a fully trained Large Language Model (LLM) is built-in. This LLM, trained using a generative adversarial network, can generate an icon for an animal based on a string description of the animal. When a program in the software system receives an animal description in unstructured string form, it inputs the animal description into the LLM. The LLM can then automatically generate an icon containing the appearance features and / or behavioral pattern features contained in the animal description. The program can then display the icon on the graphical user interface through a control request, thus simulating the role of an animal character. In this implementation, a part of the animal character's role model is the animal description (a formalized expression represented by an unstructured string).

[0395] Continuing from the above, in another software system, an unstructured string can be used to describe the character model of a desired animal role. Then, the character model (string) can be passed to the software system. The large language model in the software system can then generate the icon required for the animal role based on the descriptive information in the string, and display it on the graphical user interface, thus completing the mechanism of dynamically loading a character model provided by another software system into the software system. Here, the processing program can be a predefined processing program, or it can be a Java plugin obtained from the other software system or other software systems before receiving the animal description.

[0396] (ii) Similarly, this can be achieved using neural network-like techniques. A neural network framework is built into a software system. In this way, a neural network (character model) trained in another software system can be copied into the neural network framework of this software system by replicating parameters such as weights and biases. That is, in the other software system, through reinforcement learning training methods, this neural network learns the appearance and behavioral patterns of a character model. Through generative adversarial networks training methods, this neural network gains the ability to generate a graph based on the learned appearance features. In this implementation, the weights and biases distributed in the neurons of this neural network represent the character model, and the formal expression of this character model is the overall parameter structure within this neural network.

[0397] Following on from the above, the other software system only needs to request the software system to configure another type of neural network with the same architecture as the first type of neural network and copy those parameters to dynamically load the role model from the other software system into the first software system. The other type of neural network can be considered another role model, and the other role model is a copy of the first role model.

[0398] Following this, a process in the software system can then request the other type of neural network to generate the icon for itself, which is then displayed on the graphical user interface. When the process receives a request from the other software system for the other type of neural network, the dynamically loaded and copied other type of neural network can respond accordingly to the request based on the behavioral patterns trained on the neural network before copying. For example, if the request is a question and the response is an answer to that question, the process can display the answer on the graphical user interface or, through the network connection interface, reply to the other software system as a behavioral response. Furthermore, in the other software system, the parameters of the neural network, the rules for interacting with the other type of neural network, and the rules for driving the graphical user interface and the network connection interface can also be pre-implemented and fully wrapped in a Java plugin. In the settings of the Java plugin, an identifier (Component ID or Component...) is provided. In the implementation of the Java plugin's program code, the rules for interacting with this other type of neural network, as well as the rules for driving the graph user interface and network connection interface, are designed in the Java category of the Java plugin, and the parameters of this type of neural network are provided as additional resources for the Java plugin.

[0399] Continuing from the above, this design approach allows the Java plugin to become a self-contained component. Then, this self-contained component is dynamically loaded from the other software system, deployed on that system, and the role model (parameters of a neural network) from the plugin's attached resources is copied to another role model (the other type of neural network). This allows the driving force of the other role model to be entirely handled by the dynamically loaded self-contained component itself, that is, by the program code within the Java plugin. Therefore, when another software system sends a question to this software system, it only needs to add the identifier of the Java plugin to the question. After receiving the question, the software system can retrieve the Java plugin according to the identifier, send the question to the Java plugin, and then the Java plugin interacts with the other role model (the other type of neural network) to obtain the response of the other role model. After obtaining the response of the other role model, it drives the graph user interface or network connection interface to complete a behavior response. Under this implementation method, the software system itself does not need to contain any computational logic for role simulation.

[0400] (iii) This can be achieved through an expert system. An expert system can be built into a software system. In this way, a role model described by at least one rule and script in another software system can be copied to the expert system of the current software system by replicating at least one rule and script. That is, in another software system, within another expert system with the same architecture, there is at least one rule and script containing a role model for a specific role. This at least one rule and script is the formal expression of the role model. Then, the other software system only needs to send this at least one rule and script to the expert system and configure it to dynamically load the role model of that specific role from the other software system into the current software system.

[0401] Continuing from the above, in a preferred embodiment, when a software system dynamically loads a role model of a character from another software system, it can dynamically load all or part of the role model. For example, the role model is composed of at least one type of neural network, that is, the role model includes all formal expressions (weight values, biases, etc.) in the at least one type of neural network. However, within the at least one type of neural network, individual neural networks correspond to a portion of the role model. That is, dynamically loading the role model of a character can involve copying the entire architecture and parameters of the at least one type of neural network to dynamically load the entire role model, or it can involve copying only a portion of the architecture and parameters of some of the neural networks in the at least one type of neural network to dynamically load a portion of the role model. The implementation methods for dynamically loading all or part of the role model described herein are not limited to the above, and those skilled in the art can make any equivalent modifications according to actual application requirements.

[0402] Continuing from the above, in a preferred embodiment, when dynamically loading the pet dog 51's character model into the game software 23, the pet dog 51's character model can be obtained from another software system. For example, the robot dog operating system 21 itself does not contain the pet dog 51's character model; the pet dog 51's character model exists in another software system on another machine, which can be a server, and the other software system can be a web server. Many predefined character models of the robot dog operating system 21 itself are stored on the web server and published externally as resources. That is, each character model has a corresponding independent URL path on the web server, and a specific character model can be accessed through a specific URL path. Accordingly, when the robot dog operating system 21 sends a request to the game software 23 to dynamically load a character model, it can attach the character model's URL path to the request. In this way, after receiving the request, the game software 23 can obtain the URL path from the request content and send an HTTP GET request to the URL path to dynamically download the character model. That is, in this way, the character model can be dynamically downloaded from another software system (a software system different from the game software 23 and the robot dog operating system 21). However, the embodiment of dynamically downloading the character model from another software system described herein is not limited to the above, and those skilled in the art can make any equivalent modifications according to actual application needs.

[0403] Building upon the above, the mechanism for dynamically loading character models described in this article allows different software systems (e.g., two different, orthogonal game software programs) to dynamically load character models from each other's systems during execution, even when their respective character models only exist within their own systems. This allows the simulated characters in each system's workspace (game scene) to run in the other's workspace. The various implementation methods for dynamically loading character models described in this article are not limited to those described above, and those skilled in the art can make any equivalent modifications based on actual application needs.

[0404] Continuing from the above, in a preferred embodiment, the pet dog 51 may also transmit at least one state detected in the physical world from the robot dog operating system 21 to the game software 23. Based on the at least one state, the pet dog 51 may take at least one action (e.g., pause the operation of the game scene and remind the user) and / or send a request back to the robot dog operating system 21 based on the at least one state to drive the execution of at least another action (e.g., emit a warning sound through the speaker of the robot dog 11). The at least one state includes, but is not limited to, an event triggered by an Internet of Things device, the result of a voice / image recognition, etc.

[0405] Continuing from the above, in another preferred embodiment, the robot dog operating system 21, through the RESTful API (compliant with RESTful Level 3) of the game software 23, discovers that the game software 23, being an orthogonal system, has a resource supporting "querying the current weather," and records the resource in a list. In the pet dog 51's role model, there is a programmable script. When the programmable script determines that the user has given an instruction to query the current weather, it retrieves the relevant information of the resource (e.g., URL, HTTP Method, etc.) from the list, and then generates a request to call the resource, which serves as an association information for the pet dog 51, and drives the robot dog operating system 21 to submit the request to the game software 23. After receiving the request from the pet dog 51, the game software 23 can query the current weather through the resource and send the retrieved weather information back to the robot dog operating system 21 as a response to the request. This becomes another associated information of the pet dog 51, driving the execution of another behavioral response of the pet dog 51 (for example, displaying the weather information through an App interface of a mobile phone extended by the robot dog 11).

[0406] Figure 7 shows a schematic diagram of the operational concept of one system's role being possessed by another system's role, and Figures 3A, 3B, 3C, and 5 are also referenced. In this context, game software 23 in Figure 7 and game software 23 in Figure 5 are the same or equivalent software systems; game console 13 and game console 13 in Figure 5 are the same or equivalent machines; player 532 and player 532 in Figure 5 are the same or equivalent roles; video game scene 31 and video game scene 31 in Figure 5 are the same or equivalent workspaces; and processing program 63 and processing program 63 in Figure 5 are the same or equivalent processing programs. Similarly, robot dog operating system 21 in Figure 7 and robot dog operating system 21 in Figure 5 are the same or equivalent software systems; pet dog 51 and pet dog 51 in Figure 5 are the same or equivalent roles; processing program 61 and processing program 61 in Figure 5 are the same or equivalent processing programs; simulation result 734 is at least one simulation result generated in response to associated information 715; #sit 71 and #sit 71 in Figure 3C are the same or equivalent control request (driving the limbs to squat); #vibrate 74 is a control request that drives the robot dog 11 to shake its body.

[0407] Continuing from the above, association information 714 is at least one piece of association information for the pet dog 51. Similar to association information 712, association information 714 is arranged according to the JSON structured data structure; its content also includes an event where the user authorizes the pet dog 51 to play with him / her; it also includes at least one state of the pet dog 51 character; the request is also represented by an identifier, however, the attached request is different. This identifier is POSSESS_PLAYER_2, indicating that the pet dog 51 character requests to possess player 532, but after possession, there is no need to change player 532's clothing color. Therefore, association information 714 can be represented as follows:

[0408] {

[0409] "event": "PLAY_WITH_USER_AUTHORIZED",

[0410] "request": "POSSESS_PLAYER_2",

[0411] “character”:

[0412] {

[0413] "type": "DOG",

[0414] “color”: “WHITE”,

[0415] “behavior”: “YAPPY”

[0416] }

[0417] }

[0418] Continuing from the above, in Figure 7, the associated information 715 is at least one piece of associated information for player 532. The associated information 715 includes: A) a request, indicating a desire to possess the pet dog 51 and make it sit (e.g., REVERSE_POSSESS_AND_SIT); B) a state, describing the current emotional state of player 532 in the game scene 31 (e.g., NERVOUS indicating nervousness); C) an event, indicating an event encountered by player 532 in the game scene 31 (e.g., IN_DANGER indicating a dangerous situation); and D) a response, indicating a response after processing the associated information 714 (e.g., POSSESSION_DONE indicating possession task completed). Therefore, the associated information 715 can be represented as follows:

[0419] {

[0420] “event”: “IN_DANGER”,

[0421] "request": "REVERSE_POSSESS_AND_SIT",

[0422] “state”: “NERVOUS”,

[0423] "response": "POSSESSION_DONE"

[0424] }

[0425] Continuing from the above, in a preferred embodiment, the association information 714 is sent to the game software 23 via an HTTP request sent to a RESTful API provided by the game software 23. After the association information 714 is processed, based on the association information 714, the association information 715 can be treated as the response information of the HTTP request and sent back to the robot dog operating system 21 in the form of an HTTP Response. In this case, the association information 715 is a composite response information, that is, it is itself a response information (HTTP Response), and its content includes other requests, events, status, and response information. In another preferred embodiment, after the association information 714 is processed, based on the association information 714, the game software 23 can also send the association information 715 to the robot dog operating system 21 in the form of another HTTP Request by calling another RESTful API provided by the robot dog operating system 21. However, the technical implementation methods for transferring information from one software system to another are not limited to the above, and those skilled in the art can make any equivalent changes based on actual application needs.

[0426] Continuing from the above, in a preferred embodiment, player 532 is the second player (Player 2) in the game scene 31. The second procedural script in the player 532 character model is slightly modified to become a seventh procedural script. This seventh procedural script can perform an action based on the content of the association information 714 by following these steps:

[0427] Stop the game software 23 from controlling the player 532.

[0428] Check the current event and / or state of player 532 in the game scene.

[0429] If the event and / or state indicates that player 532 is in danger and / or feeling stressed, it is inferred that the expected request to be made for player 532 is "sit down".

[0430] Based on the event, status, and / or expected request, generate and output associated information (i.e., associated information 715) for player 532.

[0431] Continuing from the above, in a preferred embodiment, after receiving the association information 714, the game software 23 transmits it to the processing program 63 for processing. The second expert system included in the processing program 63 contains a rule that if the event information in the content of the association information 714 is "PLAY_WITH_USER_AUTHORIZED" and the request information is "POSSESS_PLAYER_2", then the seventh procedural script is executed. First, a control request is issued by function call, by calling the stop function in the player agent program, to stop the game software 23 from controlling the player 532 itself; wherein, stopping the player 532 from being automatically controlled in the game software 23 can be considered as the fifth behavioral response made by the game software 23 based on the association information 714.

[0432] Following on, the process then examines the events and / or states currently encountered by player 532 in the game scenario. It is determined that player 532 is currently facing a dangerous obstacle in the game scenario, and their emotional state value indicates tension. Therefore, it is deduced that player 532 is expected to request to "sit down." Then, based on the current event, state, and / or request, the associated information 715 is generated. Specifically, the event information in associated information 715 is set to IN_DANGER, indicating that danger is imminent; the state information in associated information 715 is set to NERVOUS, indicating that the player 532 is nervous; the request information in associated information 715 is set to REVERSE_POSSESS_AND_SIT, indicating that the player 532 requests to possess the pet dog 51 and wants to sit; and the response information in associated information 715 is set to POSSESSION_DONE, indicating that the game software 23 has completed the process of possessing the pet dog 51 to the player 532 based on associated information 714. After generating associated information 715, it can be passed to the robot operating system 21 as a response to the robot operating system 21 based on associated information 714, driving the next behavioral response of the pet dog 51. In this embodiment, the rules in the second expert system and the seventh procedural script can be regarded as part of the player 532 character model.

[0433] Continuing from the above, in a preferred embodiment, the pet dog 51 character model includes an eighth procedural script that can perform an action based on the content of the association information 715 by the following steps:

[0434] If the response in the associated information 715 is "POSSESSION_DONE", then continue with the following steps.

[0435] If the event information in the associated information 715 is "IN_DANGER" and / or the state information is "NERVOUS", a control request #vibrate 74 is sent to the robot dog operating system 21. When the robot dog operating system 21 receives the control request, it controls the body to shake according to the instructions of #vibrate 74. The robot dog 11 contains hardware components that can make the body vibrate. #vibrate 74 can be completed by making equal changes to the design according to the technical implementation method of #sit 71 described herein.

[0436] If the associated information 715 contains request information and its content is "REVERSE_POSSESS_AND_SIT", the request to reverse possession and sit down is accepted, and a control request #sit 71 is sent to the robot dog operating system 21. When the robot dog operating system 21 receives the control request, it controls the limbs to squat down according to the instructions of #sit 71.

[0437] Continuing from the above, in a preferred embodiment, the eighth procedural script does not need to rely on the response information of the association information 715. Even if the response information is not POSSESSION_DONE, but POSSESSION_REJECTED (indicating a refusal to let the pet dog 51 possess the player 532), it can still execute the corresponding steps based on the content of the event, state, and / or request information. This is because even if the response information is POSSESSION_REJECTED, it only indicates that the game software 23 cannot allow the pet dog 51 character to possess the player 532, but does not mean that the player 532 cannot possess the pet dog 51 in return.

[0438] Continuing from the above, in a preferred embodiment, the game software 23 transmits the association information 715 to the robot dog operating system 21. After receiving the association information 715, the robot dog operating system 21 transmits it to the processing program 61 for processing. The first expert system included in the processing program 61 contains a rule that if the event information in the content of the association information 715 is "PLAY_WITH_USER_AUTHORIZED" and the request information is "REVERSE_POSSESS_AND_SIT", then the eighth procedural script is executed. Based on the content of the association information 715, the eighth programmed script will issue two control requests to drive the limbs (hardware components) and body vibration components (hardware components) in the human-machine interface of the robot dog 11, causing the robot dog 11 to sit down and tremble. Driving the body to tremble can be considered the sixth behavioral response made by the robot dog operating system 21 based on the association information 715, while driving the limbs to squat down can be considered the seventh behavioral response made by the robot dog operating system 21 based on the association information 715. In this embodiment, the rules in the first expert system and the eighth programmed script can be regarded as part of the pet dog 51 character model.

[0439] Continuing from the above, the sixth behavioral response represents a change in behavioral pattern. Since the request expressed in the associated information 715 only indicates a reverse possession but does not request shaking the body, the sixth behavioral response and the requested function of the associated information 715 are not consistent. Therefore, the sixth behavioral response is a simulation result generated by the pet dog 51 based on its own role model. The sixth behavioral response acts on the pet dog 51, and the control request to drive the shaking of this component (the vibration component in the body) is included in the simulation result 734. It maps to a simulation result of the pet dog 51. The action of shaking the body can be said to be based on the simulation of the pet dog 51 role. That is, the execution of the sixth behavioral response is a mapping of the simulation result 734 of the pet dog 51 role.

[0440] As mentioned above, the seventh behavioral response and the requested function of the associated information 715 are mutually responsive and consistent, that is, the robot dog 11 is made to sit down according to the request information; the request information represented in the associated information 715 is actually the simulation result output by the simulation of the player 532's character model (requiring sitting down); therefore, although the seventh behavioral response acts on the pet dog 51, and the control request to drive this part (limbs) to squat down is also included in the simulation result 734, what is actually reflected can be said to be a simulation result of the player 532, and the action of driving the limbs to sit down can be said to be based on the simulation made on the player 532 character; that is, the execution of the seventh behavioral response can be said to be a mapping of the simulation result of the player 532 character.

[0441] Continuing from the above, the sixth and seventh behavioral responses can be selectively driven by the process 61, depending on how the rules in the eighth procedural script are defined. It can drive only one of the behavioral responses or any combination of them. Therefore, what is reflected can be said to be the simulation result of the pet dog 51 and / or the player 532 in response to the associated information 715.

[0442] Continuing from the above, in a preferred embodiment, the robot dog 11 may include another extended graphical user interface, which is an App of the robot dog 11, installed on the user 8's mobile phone and displayed on the phone's screen. After the App connects to the robot dog 11 via a wireless network, it will display the appearance of the pet dog 51 in the form of an image on the phone screen according to the description information of the character model 41, and can also output the barking of the pet dog 51 through the phone's speaker. Furthermore, the robot dog operating system 21 includes another application platform developed in the Java programming language, which can mount various Java programs (e.g., predefined handlers 61) and also supports the ability to add Java programs externally. In addition, another RESTful API supported by the robot dog operating system 21 can also meet the requirements of RESTful Level 3 and be implemented in accordance with the constraints of HATEOAS (Hypermedia as the Engine of Application State). This allows all information and / or tools in the robot dog operating system 21 to be regarded as resources, and each resource to have an independent URL, which facilitates the generation, reading, modification and deletion of the resource through HTTP requests such as GET, POST, PUT and DELETE.

[0443] Continuing from the above, in a preferred embodiment, when the game software 23 returns the associated information 715, the seventh procedural script can be adjusted by referring to the implementation of the first procedural script in this article, that is, by adding a step to add the description of the character type, appearance and / or behavioral pattern characteristics of the player 532 to the associated information 715.

[0444] Continuing from the above, in a preferred embodiment, after the robot dog operating system 21 receives the association information 715, it can refer to the implementation of the second procedural script described herein to adjust the eighth procedural script, that is, add a step to modify the appearance of the pet dog 51 displayed in the other graphical user interface according to the appearance of the player 532 in the association information 715 (for example, by dressing it in blue clothes), and combine it with the tense crouching and shaking behavior patterns, so that the appearance and / or behavior patterns of the pet dog 51 are manifested as the possessed character of the player 532.

[0445] Continuing from the above, in a preferred embodiment, the character models of player 53 and player 532 include a ninth procedural script. This ninth procedural script can refer to the implementation of the fourth procedural script and related embodiments, allowing player 53 and player 532 to dynamically extend new functions using the resources in the robot dog operating system 21. That is, it allows player 53 and / or player 532 to dynamically handle new user instructions, dynamically support new behavioral responses, and directly extend their behavioral responses to the working scenario of the robot dog 11.

[0446] Continuing from the above, in a preferred embodiment, the game software 23 can add support for another set of associated information. Referring to the implementation of the associated information 713, a description of the player 532's character type, appearance, and / or behavioral pattern characteristics is added to it, and the request information setting is changed to CREATE_NEW_ROLE. In the robot dog operating system 21, referring to the relevant embodiments of the processor 64 and the fifth procedural script, another processor can be provided to process the other associated information. This allows the robot dog operating system 21 to automatically generate a new character on the other graphical user interface based on the description of the player 532's appearance and / or behavioral pattern, and output an audio that evokes tension in humans through the speaker of the mobile phone and / or the robot dog 11. In the working scene of the robot dog 11, this new character is simulated as the avatar of the player 532.

[0447] Continuing from the above. In a preferred embodiment, referring to the application platform of the game software 23, the Java plugin of the robot dog operating system 21, the sixth procedural script, and related embodiments, the game software 23 may include another self-contained component, which is itself another Java plugin capable of handling CREATE_NEW_ROLE requests. This component contains a copy of the player 532's character model. Before the other association information carrying the CREATE_NEW_ROLE is transmitted to the robot dog operating system 21, the game software 23 first transmits the other self-contained component to the robot dog operating system 21, adds it to the other application platform, and replaces the other processor with the other self-contained component. When the robot dog operating system 21 receives the other association information, it can dynamically load the other self-contained component and model the character mapped to the player 532 in the robot dog 11's working scene.

[0448] Referring to Figures 5 and 6, in another preferred embodiment, the robot dog operating system 21 does not issue the association information 712 or 713 upon receiving the user 8's "play a game with me" instruction. Instead, the robot dog operating system 21 first receives an association information from the game software 23, which is an invitation for the pet dog 51 to join the game scene 31. After the user 8 issues an instruction to the game software 23 via remote control to invite the pet dog 51 to play, the game software 23 passes this instruction to the processing program 63. A corresponding programmed script (a script capable of processing the instruction) of the processing program 63 packages the instruction into the association information for the player 532, including a request to invite the pet dog 51 to join the game scene 31. Then, an information channel is established through a connection (e.g., calling the RESTful API provided by the robot dog operating system 21), and the association information is transmitted to the robot dog operating system 21. After receiving the association information from the game software 23, the robot dog operating system 21 transmits the association information to the processing program 61, and outputs the association information 712 or 713 to the game software 23 through a programmed script, thereby completing the various embodiments described in Figures 4 and 5.

[0449] In one preferred embodiment, the first machine can be a game console, the first software system is a game software, the second machine is a computer, and the second software system is an operating system. With equal design modifications according to the technical implementation method described herein, an intelligent assistant in the operating system can possess a character, avatar a character, or a character it reflects, and enter the scene of the game software to participate in the operation of the game scene. In another preferred embodiment, the first machine is another computer, and the first software system is another operating system. With equal design modifications according to the technical implementation method described herein, the intelligent assistants in the two operating systems can also possess a character, avatar a character, or a character they reflect, and enter each other's constructed workspaces to serve the user together.

[0450] Through the method created by this invention, a character simulated in the physical world and a character simulated in the virtual world, two different characters, can project each other's behavioral reactions into each other's characters based on their respective states and received events; allowing two different characters belonging to real-world and virtual-world scenarios to merge the events and / or states occurring in the physical and virtual worlds and make corresponding behavioral reactions; thus achieving the goal of virtual-real integration.

[0451] It should be noted that the above-described methods and scenarios for role simulation, control, and virtual-real integration are merely non-limiting embodiments adopted in this case, and are not limited to the methods and scenarios described above. Those skilled in the art can make any equivalent design changes based on actual application needs.

[0452] A role within a machine can be seen as a manifestation of intelligence. This role model may include parameters of at least one type of neural network and / or at least one rule from an expert system's knowledge base, all of which represent the intelligence of artificial intelligence. In a preferred embodiment, a role simulated within a machine, according to the method of this invention, can dynamically load portions of the role model (e.g., some parameters of the at least one type of neural network, some rules of the at least one rule) onto various machines, thereby distributing intelligence to at least one machine. This allows the role to participate in at least one work scenario constructed by at least one software system of the at least one machine, either as an attached role, an automatically generated avatar, or a role mapped to itself. In another preferred embodiment, within the at least one work scenario of the at least one machine, the attached, avatar, or mapped roles can also feed back events and / or states received from the at least one work scenario, enabling collaborative operation among themselves.

[0453] The method created by this invention allows: 1) an intelligent device to output the behavioral responses of a simulated character through another character in a virtual or real-world scene; 2) an intelligent device to allocate its intelligence to different computing devices, participating in different virtual or real-world scenes as an attached character, an automatically generated avatar, or a character it maps to, and cooperating in those different scenes; 3) the character represented by the intelligent device can be a character existing in a real-world scene (e.g., a robot dog) or a character in a virtual scene (e.g., an intelligent assistant or an artificial intelligence in a computer, mobile phone, or server). The other character can also be a character in a virtual or real-world scene. In this way, two different characters in a real-world scene, two different characters in a virtual scene, or two different characters belonging to different virtual and real-world scenes can all project their behavioral responses through each other, so that the service simulated by the character transcends the boundaries and barriers between different devices.

[0454] In summary, although this application has disclosed the embodiments above, it is not intended to limit the scope of this application. Those skilled in the art to which this application pertains can make various modifications and refinements without departing from the spirit and scope of this application. Therefore, the scope of protection of this application shall be determined by the appended claims.

[0455] The terms "in some embodiments" and "in various embodiments" are used repeatedly. These terms do not typically refer to the same embodiments; however, they may refer to the same embodiments. The terms "comprising," "having," and "including" are synonyms unless the context otherwise indicates otherwise.

[0456] The above description is merely a preferred embodiment of this application and is not intended to limit this application in any way. Although this application has been disclosed above with specific embodiments, it is not intended to limit this application. Any person skilled in the art can make some modifications or alterations to the above-disclosed technical content to create equivalent embodiments without departing from the scope of the technical solution of this application. Any simple modifications, equivalent changes and alterations made to the above embodiments based on the technical essence of this application without departing from the content of the technical solution of this application shall still fall within the scope of the technical solution of this application.

Claims

1. A method for character simulation, comprising at least the following steps: A first software system receives at least one associated information from a role in a second software system via an information channel; wherein, The first software system and the second software system are orthogonal systems to each other. The first software system runs on a first machine, and the second software system runs on a second machine. The first machine and / or the first software system provides a human-computer interface. The first software system drives a portion of the human-machine interface to make at least one behavioral response based on the at least one associated information. The at least one behavioral response is generated by driving at least one structure and / or at least one action in the portion of the interface to image at least one simulation result of the role and / or another role. The first software system transmits at least another associated information to the second software system based on the at least one associated information to drive at least another behavioral response of the role and / or the other role.

2. The method as described in claim 1, characterized in that, The at least one other piece of related information is the related information of the other role.

3. The method as described in claim 1, characterized in that, The at least one associated information and / or the at least another associated information is a request, event, status, response information, and / or any kind of information received or transmitted through the simulation of a role.

4. The method of claim 1, wherein, The content of the at least one associated information and / or the at least another associated information includes a description of an appearance and / or behavior pattern feature, a structural specification description, and / or a driver for an action; wherein the description of the appearance and / or behavior pattern feature, the structural specification description, and / or the driver for an action is presented in the form of a program file, a script file, settings, parameters, an implementation of a structure or category, a data package, or any combination thereof.

5. The method as described in claim 1, characterized in that, The at least one simulation result is at least one control request, which includes a request for change to the at least one structure and / or a request for execution of the at least one action.

6. The method of claim 5, wherein, The at least one control request is generated based on the appearance characteristics and / or behavioral patterns of the character and / or the other character. The appearance characteristics include shape, color, voice, structure, or any static characteristics that can be observed and / or identified by human senses. The behavioral patterns include communication, speaking, command processing, command operation, or any dynamic characteristics that can be observed and / or identified by human senses.

7. The method of claim 1, wherein, The at least one structure and / or the at least one action represented by this part is based on a simulation of the other character.

8. The method of claim 1, wherein, The at least one behavioral response is a mapping of the at least one simulation result of the other role; and / or the at least other behavioral response is a mapping of the at least another simulation result of the other role.

9. The method of claim 1, wherein, Before the first software system drives the at least one behavioral response, by dynamically loading a portion of the role model into the first software system, the role can participate in the work scenario constructed by the first software system through an avatar, a mapped role, or a possessed role.

10. The method of claim 1, wherein, The other character is an incarnation, a reflected character, or a possessing character of the original character.

11. The method of claim 1, wherein, Before the second software system drives the at least other behavioral response, by dynamically loading a portion of the other role's role model into the second software system, the other role can participate in the work scenario constructed by the second software system through an avatar, a mapped role, or a possessed role.

12. The method of claim 1, wherein, This character is an incarnation, a reflection of, or a possessing character of another character.

13. The method of claim 1, wherein, The role is an artificial intelligence, an intelligent agent, an intelligent assistant, a person, an animal, an organic or fictional creature, and / or any object that can be modeled based on a role model, and / or the other role is another artificial intelligence, another intelligent agent, another intelligent assistant, another person, another animal, another organic or fictional creature, and / or any other object that can be modeled based on another role model.

14. The method of claim 13, wherein, The descriptive information of the character model includes a description of the appearance and / or behavior patterns of the other character; and / or the descriptive information of the other character model includes a description of the appearance and / or behavior patterns of the character.

15. The method of claim 13, wherein, The description information of the role model is provided by the first software system; and / or the description information of the other role model is provided by the second software system.

16. The method of claim 13, wherein, When a component does not exist in the human-machine interface, the component is automatically generated based on the description information of the role model; and / or the second machine and / or the second software system provides another human-machine interface, and when another component does not exist in the other human-machine interface, the other component is automatically generated based on the description information of the other role model.

17. The method of claim 13, wherein, Dynamically load all or part of the role model into the second software system, where the role model does not exist in the second software system before dynamic loading; and / or dynamically load all or part of the other role model into the first software system, where the other role model does not exist in the first software system before dynamic loading.

18. The method of claim 13, wherein, All or part of the role model is dynamically loaded from the first software system to the second software system; and / or all or part of the other role model is dynamically loaded from the second software system to the first software system.

19. The method of claim 13, wherein, In the second software system, all or part of the role model is driven by a dynamically loaded self-contained component; and / or in the first software system, all or part of the other role model is driven by another dynamically loaded self-contained component.

20. The method of claim 13, wherein, In the second software system, the role model is a copy of all or part of the other role model; and / or in the first software system, the other role model is a copy of all or part of the other role model.

21. The method of claim 13, wherein, The role is the modeling result of the role model by the second software system, and the role model is a formal expression; and / or the other role is the modeling result of the other role model by the first software system, and the other role model is another formal expression.

22. The method of claim 21, wherein, The formal expression and / or the other formal expression includes a description of appearance and / or behavioral pattern characteristics, a structural specification description, and / or a driver for actions.

23. The method of claim 22, wherein, Based on the description of the appearance and / or behavior pattern characteristics, the specification of the structure, and / or the driver of the action, the appearance, the behavior pattern, the structure, and / or the operation performance corresponding to the role and / or the other role are presented to the corresponding human-machine interface.

24. The method of claim 21, wherein, The content of the formal expression and / or the other formal expression is presented in the form of a program file, a script file, a setting, a parameter, a structure, or an implementation of a class, and / or a data package, or any combination thereof.

25. The method of claim 24, wherein, The content of the formal expression and / or the other formal expression includes parameters in a neural network, rules in a rule base of an expert system, an implementation of an object class, a programmed script, a structured script, a structured object, an unstructured string, or any combination thereof.

26. The method of claim 24, wherein, The format of the formal expression and / or the other formal expression refers to the specification, style, and / or form of arranging, expressing, and / or representing the content of the corresponding formal expression.

27. The method of claim 26, wherein, The format of the formal expression and / or the other formal expression includes neuron structures in a neural network, representations of an expert system, syntax of a programming language, unstructured data structures, structured data structures, or any combination thereof.

28. The method of claim 21, wherein, The first software system models the other role based on the other formal expression and presents the modeling result of the other role model through the human-machine interface; and / or the second software system models the role based on the formal expression and presents the modeling result of the role model through another human-machine interface provided by the second machine and / or the second software system.

29. The method of claim 1, wherein, The second machine and / or the second software system provide another human-machine interface, which includes another part of the composition, and the at least one other behavior reaction is imitated by driving at least one other structure and / or at least one other action in the other part of the composition to present at least one other simulation result of the role and / or the other role.

30. The method of claim 29, wherein, The at least one other simulation result is at least one other control request; wherein the at least one other control request includes a change request for the at least one other structure and / or an execution request for the at least one other action.

31. The method of claim 30, wherein, The at least one other control request is generated based on the at least one association information; and / or the at least one other control request is generated based on the appearance characteristics and / or the behavior pattern characteristics of the role and / or the other role, the appearance characteristics including modeling, color, sound line, structure, or any static feature that can be observed and / or recognized by human senses, and the behavior pattern characteristics including communication, speaking, instructing operation, instructing operation, or any dynamic feature that can be observed and / or recognized by human senses.

32. The method of claim 29, wherein, The at least one other structure and / or the at least one other action presented by the other part of the composition are based on the simulation of the role.

33. The method of claim 1, wherein, The second machine and / or the second software system provides another human-machine interface through which another work space applied to another scene is constructed; wherein the work space and the another work space are orthogonal work spaces to each other; wherein the another role enters the work space from the another work space to run in the execution period, and / or the role enters the another work space from the work space to run in the execution period.

34. The method of claim 1, wherein, The orthogonal system means that the first software system and the second software system are independent in function and do not depend on each other; and are based on support for a communication protocol to transmit data between each other.

35. A role simulation method, comprising at least the following steps: A first software system transmits at least one associated information of a role to a second software system through an information channel; wherein, The first software system and the second software system are orthogonal systems to each other, the first software system is executed on a first machine, the second software system is executed on a second machine, and the second machine and / or the second software system provides a human-machine interface; and The second software system drives at least one behavior reaction of a part of the human-machine interface based on the at least one associated information, and the at least one behavior reaction is used to reflect at least one simulation result of the role and / or another role by driving at least one structure and / or at least one action of the part of the human-machine interface, and / or the second software system transmits at least another associated information to the first software system based on the at least one associated information to drive at least another behavior reaction of the role and / or the another role.

36. The method of claim 35, wherein, The at least another associated information is associated information of the another role.

37. The method of claim 35, wherein, The at least one associated information and / or the at least another associated information is a request, an event, a state, response information, and / or any information received or transmitted by simulation of the role.

38. The method of claim 35, wherein, The content of the at least one associated information and / or the at least another associated information includes description of appearance and / or behavior pattern characteristics, specification description of structure, and / or designation of action driver; wherein the appearance and / or behavior pattern characteristics, the specification description of structure, and / or the action driver are in the form of a program file, a script file, a setting, a parameter, an implementation of a structure or a class, a data package, or any combination thereof.

39. The method of claim 35, wherein, The at least one simulation result is at least one control request, and the at least one control request includes a change request of the at least one structure and / or an execution request of the at least one action.

40. The method of claim 39, wherein, The at least one control request is generated based on appearance characteristics and / or behavior pattern characteristics of the role and / or the another role, the appearance characteristics include modeling, color, sound line, structure, or any static feature that can be observed and / or recognized by human senses, and the behavior pattern characteristics include communication, speaking, instruction operation, instruction operation, or any dynamic feature that can be observed and / or recognized by human senses.

41. The method of claim 35, wherein, The at least one structure and / or the at least one action displayed by the part of the human-machine interface are based on simulation of the another role.

42. The method of claim 35, wherein, The at least one behavioral response is a mapping of the at least one simulation result of the other role; and / or the at least other behavioral response is a mapping of the at least another simulation result of the other role.

43. The method of claim 35, wherein, Before the second software system drives the at least one behavioral response, by dynamically loading a portion of the role model into the second software system, the role can participate in the work scenario constructed by the second software system through an avatar, a mapped role, or a possessed role.

44. The method of claim 35, wherein, The other character is an incarnation, a reflected character, or a possessing character of the original character.

45. The method of claim 35, wherein, Before the first software system drives the at least other behavioral response, by dynamically loading a portion of the other role's role model into the first software system, the other role can participate in the work scenario constructed by the first software system through an avatar, a mapped role, or a possessed role.

46. The method of claim 35, wherein, This character is an incarnation, a reflection of, or a possessing character of another character.

47. The method of claim 35, wherein, The role is an artificial intelligence, an intelligent agent, an intelligent assistant, a person, an animal, an organic or fictional creature, and / or any object that can be modeled based on a role model, and / or the other role is another artificial intelligence, another intelligent agent, another intelligent assistant, another person, another animal, another organic or fictional creature, and / or any other object that can be modeled based on another role model.

48. The method of claim 47, wherein, The descriptive information of the character model includes a description of the appearance and / or behavior patterns of the other character; and / or the descriptive information of the other character model includes a description of the appearance and / or behavior patterns of the character.

49. The method of claim 47, wherein, The description information of the role model is provided by the second software system; and / or the description information of the other role model is provided by the first software system.

50. The method of claim 47, wherein, When a component does not exist in the human-machine interface, the component is automatically generated based on the description information of the role model; and / or the first machine and / or the first software system provides another human-machine interface, and when another component does not exist in the other human-machine interface, the other component is automatically generated based on the description information of the other role model.

51. The method of claim 47, wherein, Dynamically load all or part of the role model into the first software system, where the role model does not exist in the first software system before dynamic loading; and / or dynamically load all or part of the other role model into the second software system, where the other role model does not exist in the second software system before dynamic loading.

52. The method of claim 47, wherein, All or part of the role model is dynamically loaded from the second software system into the first software system; and / or all or part of the other role model is dynamically loaded from the first software system into the second software system.

53. The method of claim 47, wherein, In the first software system, all or part of the role model is driven by a dynamically loaded self-contained component; and / or in the second software system, all or part of the other role model is driven by another dynamically loaded self-contained component.

54. The method of claim 47, wherein, In the first software system, the role model is a copy of all or part of the other role model; and / or in the second software system, the other role model is a copy of all or part of the other role model.

55. The method of claim 47, wherein, The role is the modeling result of the first software system of the role model, which is a formal expression; and / or the other role is the modeling result of the second software system of the other role model, which is another formal expression.

56. The method of claim 55, wherein, The formal expression and / or the other formal expression includes a description of appearance and / or behavioral pattern characteristics, a structural specification description, and / or a driver for actions.

57. The method of claim 56, wherein, Based on the description of the appearance and / or behavioral characteristics, the specification description of the structure, and / or the driver program of the action, the appearance, behavioral pattern, structure and / or operation of the corresponding role and / or the other role are displayed on the corresponding human-machine interface.

58. The method of claim 55, wherein, The formal expression and / or the content of the other formal expression are presented in the form of an implementation of a program file, script file, settings, parameters, structure, or class, and / or a data package, or any combination thereof.

59. The method of claim 58, wherein, The content of the formal expression and / or the other formal expression includes parameters in a neural network, rules in an expert system rule base, implementations of object categories, procedural scripts, structured scripts, structured objects, unstructured strings, or any combination thereof.

60. The method of claim 58, wherein, The format of the formal expression and / or the format of the other formal expression refers to a specification, style and / or form for arranging, expressing and / or representing the corresponding formal expression content.

61. The method of claim 60, wherein, The format of the formal expression and / or the other formal expression includes the neuronal structure in a neural network, the representation of an expert system, the syntax of a programming language, an unstructured data structure, a structured data structure, or any combination thereof.

62. The method of claim 55, wherein, The second software system models the other role based on the other formal expression and presents the modeling result of the other role model through the human-computer interface; and / or the first software system models the role based on the formal expression and presents the modeling result of the role model through the first machine and / or another human-computer interface provided by the first software system.

63. The method of claim 35, wherein, The first machine and / or the first software system provides another human-machine interface, which includes another component, and the at least another behavioral response is to image at least another simulation result of the role and / or the other role by driving at least another structure and / or at least another action in the other component.

64. The method of claim 63, wherein, The at least other simulation result is at least another control request; wherein the at least other control request includes a request for change to the at least other structure and / or a request for execution of the at least other action.

65. The method of claim 64, wherein, The at least one other control request is generated based on the at least one associated information; and / or the at least one other control request is generated based on the appearance characteristics and / or behavioral pattern characteristics of the character and / or the other character, the appearance characteristics including shape, color, voice, structure or any static characteristics that can be observed and / or identified by human senses, and the behavioral pattern characteristics including communication, speaking, command calculation, command operation or any dynamic characteristics that can be observed and / or identified by human senses.

66. The method of claim 63, wherein, The at least one other structure and / or the at least one other action expressed through the other component is based on a simulation of the character.

67. The method of claim 35, wherein, The human-machine interface constructs a workspace applicable to a scenario; the first machine and / or the first software system provides another human-machine interface, through which another workspace applicable to another scenario is constructed; wherein the workspace and the other workspace are orthogonal to each other; wherein the other role enters the workspace from the other workspace to run during the execution period, and / or the role enters the other workspace from the workspace to run during the execution period.

68. The method of claim 35, wherein, The orthogonal system refers to the first software system and the second software system being functionally independent and not dependent on each other; they transmit data between each other based on the support of a communication protocol.

69. A method for communication between roles, comprising at least the following steps: communicating a first associated information of a first role to a second role through an information channel; wherein The first role and the second role are independent roles; as well as A second role performs a corresponding process based on the first association information, outputs the execution result of the process as a second association information, and sends the second association information back to the first role through the information channel.

70. The method of claim 69, wherein, The first role is an artificial intelligence, an intelligent agent, an intelligent assistant, and / or any object that can be modeled based on the first role model, and / or the second role is another artificial intelligence, another intelligent agent, another intelligent assistant, and / or any other object that can be modeled based on the second role model.

71. The method of claim 70, wherein, The first character model and / or the second character model includes a description of appearance and / or behavioral characteristics, a structural specification description, and / or a driver for actions.

72. The method of claim 71, wherein, Based on the description of the appearance and / or behavioral characteristics, the specification description of the structure, and / or the driver program for the action, the appearance, behavioral pattern, structure, and / or operation of the corresponding first role and / or the second role will be displayed on the corresponding human-machine interface.

73. The method of claim 70, wherein, The content of the first role model and / or the second role model is presented in the form of an implementation of a program file, script file, settings, parameters, structure or category, and / or a data package, or any combination thereof.

74. The method of claim 73, wherein, The content of the first role model and / or the second role model includes parameters in a neural network, rules in an expert system rule base, implementations of object categories, procedural scripts, structured scripts, structured objects, unstructured strings, or any combination thereof.

75. The method of claim 73, wherein, The format of the first character model and / or the second character model refers to a specification, style and / or form for arranging, expressing and / or representing the corresponding character model content.

76. The method of claim 75, wherein, The format of the first role model and / or the second role model includes the neuron structure in a neural network, the representation of an expert system, the syntax of a programming language, an unstructured data structure, a structured data structure, or any combination thereof.

77. The method of claim 69, wherein, The information channel is a network transmission channel, which is established based on at least one communication protocol, and at least one information data is transmitted based on the at least one communication protocol.

78. The method of claim 69, wherein, The first associated information and / or the second associated information is a request, event, status, response information, and / or any kind of information received or transmitted through the simulation of a role.

79. The method of claim 78, wherein, The content of the first associated information and / or the second associated information includes a description of an appearance and / or behavioral pattern feature, a structural specification description, and / or a driver for an action; wherein the description of the appearance and / or behavioral pattern feature, the structural specification description, and / or the driver for the action are presented in the form of a program file, a script file, settings, parameters, an implementation of a structure or category, a data package, or any combination thereof.

80. The method of claim 78, wherein, The first associated information and / or the second associated information is at least one control request, which includes a request for change of at least one structure and / or a request for execution of at least one action.

81. The method of claim 69, wherein, The first associated information is a request, the content of which contains at least one identifier and at least one parameter.

82. The method of claim 81, wherein, The at least one identifier and / or the at least one parameter includes a task method to be executed by the request and the parameter content required to execute the task method.

83. The method of claim 82, wherein, The at least one identifier and / or the at least one parameter contains authorization information indicating that the request has been authorized.

84. The method of claim 69, wherein, The second software system includes a published list of resources, which includes at least one resource, the contents of which contain description information of at least one executable task method.

85. The method of claim 84, wherein, The at least one task method includes at least one structure, at least one action, at least one tool, and / or at least one information access method supported by the second software system and / or the second role.

86. The method of claim 85, wherein, The processing includes changes to the at least one structure, the execution of the at least one action, the driving of the at least one tool, and / or access to the at least one piece of information.

87. The method of claim 84, wherein, Before transmitting the first association information to the second software system, the first software system queries the resource list from the second software system.

88. The method of claim 87, wherein, Before the first association information is generated, after the first role receives an instruction from the user, it inputs the instruction and the resource list into a neural network. Through the inference of the neural network, it finds a resource suitable for executing the instruction and generates the first association information based on the description information of an executable task method contained in the resource.

89. The method of claim 88, wherein, This type of neural network is a major language model.

90. The method of claim 69, wherein, The content of the second associated information is a response information, which contains the execution result.

91. The method of claim 69, wherein, The first role operates in the first software system, and the second role operates in the second software system; wherein the first software system is executed on the first machine, and the second software system is executed on the second machine.

92. The method of claim 91, wherein, The first software system and the second software system are orthogonal systems to each other. The orthogonal system means that the first software system and the second software system are functionally independent and do not depend on each other. They transmit data between each other based on the support of a communication protocol.

93. A method for extending role functionality, comprising at least the following steps: communicating an associated information of a character to another software system through an information channel; wherein, This associated information contains at least one request; and The other software system, based on the at least one request, sends another role model back to the role through the information channel, and the role extends at least one function based on the other role model.

94. The method of claim 93, wherein, The role is an artificial intelligence, an intelligent agent, an intelligent assistant, and / or any object that can be modeled based on a role model.

95. The method of claim 94, wherein, The character model and / or the other character model includes a description of appearance and / or behavioral characteristics, a structural specification description, and / or a driver for the action.

96. The method of claim 95, wherein, Based on the description of the appearance and / or behavioral characteristics, the specification description of the structure, and / or the driver program of the action, the appearance, behavioral pattern, structure and / or operation of the character are represented in the corresponding human-computer interface.

97. The method of claim 94, wherein, The content of the character model and / or the other character model is presented in the form of a program file, script file, settings, parameters, structure or category implementation, and / or data package, or any combination thereof.

98. The method of claim 97, wherein, The content of the role model and / or the other role model includes parameters in a neural network, rules in an expert system rule base, implementations of object categories, procedural scripts, structured scripts, structured objects, unstructured strings, or any combination thereof.

99. The method of claim 97, wherein, The format of the character model and / or the other character model refers to a specification, style and / or form in which the content of the corresponding character model is arranged, expressed and / or represented.

100. The method of claim 99, wherein, The format of the role model and / or the other role model includes the neuron structure in a neural network, the representation of an expert system, the syntax of a programming language, an unstructured data structure, a structured data structure, or any combination thereof.

101. The method of claim 93, wherein, The information channel is a network transmission channel, which is established based on at least one communication protocol, and at least one information data is transmitted based on the at least one communication protocol.

102. The method of claim 93, wherein, The other character model is passed to that character via another set of related information.

103. The method of claim 102, wherein, The associated information and / or the other associated information is a request, event, status, response information, and / or any kind of information received or transmitted through the simulation of a role.

104. The method of claim 103, wherein, The content of the associated information and / or the other associated information includes a description of an appearance and / or behavior pattern feature, a structural specification, and / or a driver for an action; wherein the description of the appearance and / or behavior pattern feature, the structural specification, and / or the driver for the action are presented in the form of a program file, a script file, settings, parameters, an implementation of a structure or category, a data package, or any combination thereof.

105. The method of claim 93, wherein, The at least one request includes a request to obtain the model of the other role.

106. The method of claim 94, wherein, The extension of at least one function is accomplished by dynamically loading the other character model, which does not exist in the character model before dynamic loading.

107. The method of claim 93, wherein, The other software system includes a published list of resources, which includes at least one resource, the content of which contains description information of at least one character model; wherein the at least one character model contains a driver for at least one action.

108. The method of claim 107, wherein, Before transmitting the associated information to the other software system, the role queries the resource list from the other software system.

109. The method of claim 108, wherein, Before the associated information is generated, after receiving an instruction from the user, the role inputs the instruction and the resource list into a neural network. Through the inference of the neural network, a role model suitable for executing the instruction is found, and then the associated information is generated.

110. The method of claim 109, wherein, This type of neural network is a major language model.

111. The method of claim 93, wherein, The role operates within a software system; wherein the software system runs on a first machine, and the other software system runs on a second machine.

112. The method of claim 111, wherein, The software system and the other software system are orthogonal systems to each other. An orthogonal system means that the software system and the other software system are functionally independent and do not depend on each other. They transmit data between each other based on the support of a communication protocol.

Images