CN112604273A - Data-driven game system function loading method, device and storage medium - Google Patents
Data-driven game system function loading method, device and storage medium Download PDFInfo
- Publication number
- CN112604273A CN112604273A CN202011553075.4A CN202011553075A CN112604273A CN 112604273 A CN112604273 A CN 112604273A CN 202011553075 A CN202011553075 A CN 202011553075A CN 112604273 A CN112604273 A CN 112604273A
- Authority
- CN
- China
- Prior art keywords
- class
- data
- scene
- unit
- data unit
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- A—HUMAN NECESSITIES
- A63—SPORTS; GAMES; AMUSEMENTS
- A63F—CARD, BOARD, OR ROULETTE GAMES; INDOOR GAMES USING SMALL MOVING PLAYING BODIES; VIDEO GAMES; GAMES NOT OTHERWISE PROVIDED FOR
- A63F13/00—Video games, i.e. games using an electronically generated display having two or more dimensions
- A63F13/45—Controlling the progress of the video game
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Multimedia (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The embodiment of the application provides a data-driven game system function loading method, equipment and a storage medium. The source file of the system comprises a plurality of classes which are stored with behavior units, and each class is provided with a class description; when the scene management function of the game is loaded, the member methods in which classes are called are determined according to the externally input data (namely configuration data) to create the scene management unit, the scene management logic of the game system can be determined based on the external data, and the data driving of the game system is realized. On the premise that the behavior of the system is determined by externally input data, the operation behavior of the game system can be changed by changing the externally input data, so that a new system function is realized, and the usability and reusability of the system are improved.
Description
Technical Field
The present application relates to the field of internet technologies, and in particular, to a method, an apparatus, and a storage medium for loading functions of a data-driven game system.
Background
A large system needs to organize and manage a large amount of data and to process the corresponding data using corresponding behaviors. Typically, similar data, or data that needs to be used in an activity, will be organized together. When a system executes a certain function based on data, it needs to find out the behaviors corresponding to the data and execute the behaviors on the data. In a large-scale system, how to process shared data and behaviors and create a reasonable association mode for the data and the behaviors are key links for improving the performance of the system.
In a common prior art, common data and behaviors are extracted as units respectively, and different system functions are realized based on a unit combination mode. However, in this method, the extracted cells are not directly oriented to the system function, and readability and usability are poor. Meanwhile, the coupling of the behavior unit and the data unit is high, which is not beneficial to improving the cohesion of the system. Therefore, a new solution is yet to be proposed.
Disclosure of Invention
Aspects of the present application provide a method, device and storage medium for loading functions of a data-driven game system, so as to improve the cohesion of the system and the reusability of system codes.
The embodiment of the application provides a data-driven game system scene management function loading method, and a source file of a game system comprises: a plurality of classes, each class having a class description; the classes are used for storing the scene management units and the classes used for storing the scene data units, and are mutually decoupled; the method comprises the following steps: acquiring configuration data of the game system, wherein the configuration data comprises an identifier of a scene management unit corresponding to a scene management function to be loaded; determining a class description of a first target class corresponding to the identification of the scene management unit from the registered class descriptions based on a reflection mechanism; according to the class description of the first target class, inquiring a member method corresponding to the scene management unit from the first target class; and calling a member method corresponding to the scene management unit, and creating the scene management unit in a memory of the game system so as to drive a scene management function of the game system based on the configuration data.
Further optionally, the scene management unit includes: a binary tree scene management unit, a quad tree scene management unit, or an octree scene management unit.
Further optionally, before invoking the member method corresponding to the scene management unit and creating the scene management unit in the memory of the game system, the method further includes: determining an identification of a scene data unit required by the game system; based on a reflection mechanism, determining a class description of a second target class in which the scene data unit is located according to the identifier of the scene data unit; accessing the second target class in the resource file according to the class description of the second target class to obtain the scene data unit; and loading the scene data unit into a memory for use by the scene management unit, so as to drive the scene management function of the game system based on the scene data unit.
Further optionally, the method further comprises: responding to the editing operation of an editor, and determining the identifier of a scene data unit to be edited; determining the class description of a third target class in which the scene data unit to be edited is located according to the identifier of the scene data unit to be edited; determining member variables corresponding to the scene data unit to be edited from the third target class according to the class description of the third target class based on a reflection mechanism; assigning values to the editing objects in the code template of the editor according to the member variables to obtain editing codes of the scene data units to be edited; and operating the editing codes of the scene data units to be edited, and generating an editing panel of the scene data units to be edited so that a user can edit the scene data units to be edited.
Further optionally, determining, based on a reflection mechanism and according to the class description of the third target class, a member variable corresponding to the scene data unit to be edited from the third target class, including: accessing member variables in the third target class based on the class description of the third target class; if the type of the accessed member variable is a basic data type, taking the accessed member variable as a member variable corresponding to the scene data unit to be edited; if the type of the accessed member variable is the type of the class description, performing recursive traversal on the accessed member variable based on the class description of the accessed member variable until the member variable of the basic data type is accessed and is used as the member variable corresponding to the scene data unit to be edited.
Further optionally, the method further comprises: responding to the operation of the newly added scene management unit, and acquiring the class description of a fourth target class in which the newly added scene management unit is positioned; and registering the class description of the fourth target class to update the registered class description so as to access the newly added scene management unit subsequently according to the class description of the fourth target class.
Further optionally, the method further comprises: responding to the operation of newly adding a scene data unit, and acquiring the class description of a fifth target class in which the newly added scene data unit is positioned; and registering the class description of the fifth target class to update the registered class description so as to access the newly added scene data unit subsequently according to the class description of the fifth target class.
Further optionally, the method further comprises: acquiring real-time load data of the game system; displaying the real-time load data so that a user can update the configuration data according to the real-time load data; and acquiring updated configuration data, and dynamically adjusting a scene management unit which runs in the game system in real time according to the updated configuration data.
Further optionally, the method further comprises: determining a scene management function module contained in the game system; and splitting the scene management function module according to the sub-scene management functions contained in the scene management function module to obtain the scene management units corresponding to the plurality of sub-scene management functions.
In the function loading system of the game system provided by the embodiment of the application, a source file of the system comprises a plurality of classes in which behavior units are stored, and each class has a class description; when the scene management function of the game is loaded, the member methods in which classes are called are determined according to the externally input data (namely configuration data) to create the scene management unit, the scene management logic of the game system can be determined based on the external data, and the data driving of the game system is realized. On the premise that the behavior of the system is determined by externally input data, the operation behavior of the game system can be changed by changing the externally input data, so that a new system function is realized, and the usability and reusability of the system are improved.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:
fig. 1 is a schematic flowchart of a system function loading method according to an exemplary embodiment of the present application;
FIG. 2 is a schematic flow diagram of a runtime creation subsystem provided by an exemplary embodiment of the present application;
FIG. 3 is a flowchart illustrating a method for loading functions of a game system according to an exemplary embodiment of the present application;
fig. 4 is a schematic structural diagram of an electronic device according to an exemplary embodiment of the present application.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the technical solutions of the present application will be described in detail and completely with reference to the following specific embodiments of the present application and the accompanying drawings. It should be apparent that the described embodiments are only some of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
A system with specific functions needs to organize and manage a large amount of data and process the corresponding data with corresponding behaviors. Typically, similar data, or data that needs to be used in an activity, will be organized together. The system finds the behaviors corresponding to the data through some solutions and executes the behaviors on the data to complete the execution of one system function.
When building a system, the following points are usually needed to improve the system performance:
first, how to handle shared data and behavior. The need for a system provides a multitude of different functions, some of which require some common data and behavior. Therefore, when designing a system, if a plurality of functions can share part of data and behaviors, it is possible to avoid repeatedly implementing the same data structure in each behavior.
And secondly, the association mode of data and behaviors. Each action requires specific data, and how to find the required data when executing a certain action determines the coupling degree of the action and the data. If the coupling between the behavior and the data is too high, the reusability of the behavior and the data is deteriorated, and further, when a similar behavior is realized for a similar data structure, a large amount of codes are easily added due to a slight difference.
And thirdly, how to describe data and behaviors to realize functions. The data structures and behaviors are typically hard-coded with specific code. If different functions need to be realized, codes need to be directly modified to modify a data structure or behavior logic, so that the expansion cost and the maintenance cost of the system are higher.
In view of the above technical problems, in some embodiments of the present application, a solution is provided, which on one hand decouples the relationship between the operation logic and the behavior and data of the system function, and on the other hand, adopts a data driving concept, so that the system function is driven by externally input data, thereby improving the cohesion of the system. The technical solutions provided by the embodiments of the present application are described in detail below with reference to the accompanying drawings. In the embodiment of the application, the functions of the system can be previously split into a plurality of behavior units (or called components) and a plurality of data units according to the functions of the system, that is, behaviors and data which need to be shared are extracted as units to be shared.
The data unit comprises a group of data which are strongly related in logic and use. For example, the data unit may include: location data unit, color data unit, distance data unit, angle data unit, scene data unit, etc.
The behavior unit includes a function that can perform a specific operation on data. One unit of behavior can be used to perform one behavior alone. For example, the behavior unit may include: a move (move) unit, a culling (culling) unit, a rendering (render) unit, a data management (management) unit, and so on.
The system in this embodiment may be implemented as a game system, a logistics storage system, a business over management system, and the like, but the embodiment includes but is not limited to this. When the system needs to be implemented as a system with a specific function, the function of the system can be split into an appropriate behavior unit and an appropriate data unit according to the business logic of the system.
Taking the system implemented as a game system as an example, in a game scene, the functions of objects (entities) in the game system can be decomposed into a plurality of behavior units and data units required by the behaviors, and the units are combined to obtain the final entities in the game system.
The combination of the action units and the data units can be various, and game entities with different functions can be obtained by freely combining the action units and the data units based on various kinds. For example, for objects in a game system, position data is needed, as well as the act of updating the position data. At this time, the location data unit and the behavior unit of the mobile location can be extracted to be shared by all entities.
The behavior unit and the data unit can be respectively packaged in the classes, and the behavior unit and the data unit are located in different classes to achieve decoupling between the behavior unit and the data unit. That is, among the plurality of classes included in the system source file, the class for storing the behavior unit and the class for storing the data unit are decoupled from each other to reduce the dependency relationship between the data unit and the behavior unit. The behavior taken by the action unit may depend on the data content contained in the data unit combined with the action unit.
Continuing with the game system as an example, in a game scenario, a pointer or index of a class of data units may be stored in a game entity, and the data units may be obtained through the pointer or index. A pointer or index to a set of data elements may constitute a game entity. When the data units of the game entity are combined with different behavior units, different functions of the game entity can be realized. For example, when a color data unit of a game entity is combined with a rendering unit, the rendering unit may implement a color rendering function of the game entity; when the color data unit of the game entity is combined with the light-emitting unit, the light-emitting unit can realize the function of enabling the game entity to emit light with color; when the color data unit of the game entity is combined with the drawing unit, the drawing unit can realize the function of drawing the image with the specific color by the game entity, and the description is omitted.
In the present embodiment, a method for accessing a data unit and a behavior unit based on a "reflection (reflection) mechanism" is provided. In the reflection mechanism, for each class packaged with a data unit and a behavior unit, a corresponding class description is generated, and when the system runs, the class can be accessed, detected or modified through the class description. The class description comprises information of member variables, member functions, static variables, static functions, alignment modes, memory sizes, class names, inheritance relationships and the like of the class.
In some embodiments, the class description obtained based on the method provided by this embodiment may include a Type (Type) of the class, a member list number of the class: list < ClassDataMember >, List of Member methods in class methods: list < ClassMethod >, class name: const char, etc.
When accessing data in the class based on the class description, a pre-written access function can be adopted, and the accessed class description is used as a variable in the function, so that the data in the class is accessed. In some embodiments, the function of accessing a class according to a class description may include:
and according to the description name of the data member in the class description, searching a function of the data member in the class: findMember (const char name): const ClassDataMember.
According to the description name of the member method in the class description, searching a function of the member method in the class: findMethod (const char name): const ClassDataMethod.
Function to detect inheritance relationships: IsTypeOf (const ClassDescriptor cd): and (4) a sol.
Function to detect whether a member variable is included: hasMember (const char name): and (4) a sol.
Function to detect whether a member method is included: hasMethod (const char name): and (4) a sol.
Function to get the name of the class description: getName (): const char.
The above functions are only used for exemplary illustration, and the functions provided by the embodiments of the present application for implementing reflection include, but are not limited to, the above functions. The function can be used as a code template, and can be reused when a developer encodes, so that the access to the class of any data structure is realized.
Optionally, to implement the reflection mechanism, a class description (ClassDescriptor) of each class in the system may be registered in advance, and the identifier of the registered class and the corresponding relationship of the class description may be organized to generate index information for querying. Furthermore, when a certain class is accessed, the identification of the class can be provided, and based on the identification of the class, query is carried out in the index information to obtain class description of the class.
The identification of the class may be a name of the class, and the name may be represented by a character string. For example, for class M to be queried, a class description of class M may be obtained by typedistpenser. The reflection mechanism may be implemented based on C + + (a programming language), or may be implemented based on other types of programming languages, which is not limited in this embodiment.
Based on the above, an embodiment of the present application provides a method for loading functions of a data-driven game system, where fig. 1 is a schematic flow chart of the method for loading functions of a data-driven game system, and as shown in fig. 1, the method includes:
And 102, determining the class description of the first target class corresponding to the identification of the behavior unit from the registered class descriptions based on a reflection mechanism.
And 104, calling a member method corresponding to the behavior unit, and creating the behavior unit in a memory of the system so as to drive the function of the system based on the configuration data.
And configuring data to configure the functional requirements of the system. Typically, this configuration data may be written in a configuration file. After determining the operating logic of the system, a user or a system function developer may write, in a configuration file, an identification of one or more behavior units required to implement one or more functions of the system. The identifier of the behavior unit may be a name of the behavior unit, or a number of the behavior unit, and the embodiment is not limited.
As shown in FIG. 2, after the configuration file is entered into the system, a reflection operation may be performed by the reflection module according to the configuration file. In the reflection operation, the target class where the behavior unit corresponding to the function to be loaded is located can be determined according to the corresponding relation between the identifier of the behavior unit and the class, and the class description of the target class is determined from the registered class descriptions. For convenience of description and distinction, the target class in which the behavior unit is located is described as a first target class.
After the class description of the first target class is determined, the first target class can be uniquely determined according to the class description of the first target class, and the member method corresponding to the behavior unit is inquired from the first target class. After the member method corresponding to the behavior unit is inquired, the member method can be called and executed to create the behavior unit in the memory of the system. One of the behavior units may also be referred to as a subsystem, as shown in fig. 2. After one or more subsystems are created based on the class description and reflection mechanism, the one or more subsystems may be managed by a system manager, which is not described herein.
The following description will be given with reference to specific examples.
It is assumed that there exists class a, which contains member variables number 1, number 2, and number 3, and member methods 1, method 2. If a reflection mechanism based on class descriptions is not used, then given class A instance a, when method1 is called, the following call is required:
a.method1()；
this way of invoking depends on the structure of instance a at compile time and requires explicit knowledge of whether class A has method1, requiring a check at compile time.
If the reflection mechanism provided by the embodiment based on the class description is used, the following can be called:
Method*method1＝classDescriptorOfA.findMethod(“method1”)；
If(method1！＝nullptr){invoke()；}
wherein, classDescriptorOfA represents the class description corresponding to the class A;
classdescriptorona findmethod ("method 1"), which means that a specified member method "method 1 is looked up from class a according to the class description corresponding to class a.
This manner of invocation does not depend on any structure at compile time, but only on the lookup and invocation of methods at runtime. At call time, it is not necessary to know whether this class has this method, nor is it necessary to check at compile time.
For example, a function has an input parameter obj, and when the moveTo () method of this input class is called, if the reflection mechanism based on the class description is not used, it should know the type of the incoming class, such as a & obj, or B & obj, and then call obj.
If a reflection mechanism based on class description is used, only one input parameter of void obj and one class description (ClassDescriptor) are needed to make the method call, and the type of the parameter at compile time does not need to be known.
For example, when detecting classes through class descriptions, the class descriptions may be used to detect relationships between classes. For example, the inheritance relationship of class a may be detected by class descriptor a.
For example, when the class is modified by the class description, the class description of the member variable in the class can be found first based on the class description, and then the member variable is modified based on the modification function and the class description of the member variable.
For example, the description dataMemberDescriptor of the member variable may be obtained using classdescriptor.
For another example, a class contains a member variable position, a type of vector, a member variable Color, and a type of Color. When outputting the information of this class, display (object) can be called to output based on the reflection mechanism, as shown in the following code:
the displayPOD () can process all basic data types, and the output function can display data in any class. If a reflection mechanism based on class description is not used, then, if the output of information can be performed on all classes, a reloading method matched with the number of the classes needs to be written, and the workload is very high.
In this embodiment, the source file of the system comprises a plurality of classes in which behavior units are stored, each class having a class description; when the function is loaded, the method decides which member methods in the classes are called to create the behavior unit according to the externally input data (namely, configuration data), and can determine the system operation logic based on the external data, thereby realizing the data driving of the system. On the premise that the behavior of the system is determined by externally input data, the operation behavior of the system can be changed by changing the externally input data, so that a new system function is realized, and the usability and reusability of the system are improved.
In some alternative embodiments, when the system is implemented as a gaming system, the gaming engine may need to organize and manage a large number of objects in a game scene. Through good organization, the engine can quickly complete the operations of indexing, traversing, screening and the like of the objects. To achieve this, the engine uses some specific data structures, such as binary, quadtree, octree. Different data structure area management needs to be used for different scenes.
In the prior art, when configuring a data structure, each data structure corresponds to an enumeration value, and it is necessary to determine the data structure based on the enumeration value and generate a specified data structure through a function. For example:
in the above process, on one hand, there may be a risk (overflow) of forcibly converting the int type stored in the configuration file, and the error value is not easy to be checked. On the other hand, adding a new type requires rewriting of the switch-case code block in generatecodegraph. When there is more similar logic in the system, the modification effort is huge.
If the reflection mechanism based on the class description provided in this embodiment is adopted, the scene data of the game may be managed based on the following method, as shown in fig. 3, including:
Wherein, this scene management unit includes: a binary tree scene management unit, a quad tree scene management unit, or an octree scene management unit. When the scene management unit is selected to execute the scene management function of the game system, the scene management unit needing to be loaded can be executed through the configuration file. The following is an exemplary description in conjunction with code.
Alternatively, the operation of determining the class containing the scene management unit based on the reflection mechanism may be implemented by a ClassDescriptor. Wherein, ClassDescriptor can directly use the character string corresponding to the class identifier to query through TypeDispenser ().
In a game scene, based on a behavior unit with a management function (namely, a scene management unit), the operation of managing scene data can be configured through a configuration file, as follows:
based on the above codes, the scene can be managed by directly generating a corresponding SceneGraph (behavior unit for organizing scene graph data) from the configuration file (SettingFile), without converting the content of the configuration file into enumeration value content. By modifying the configuration file, the scene management data structure to be generated by the system can be directly influenced.
Meanwhile, compared with the prior art, when a new scene management mode is added, the existing code can be used for completing the processing without rewriting switch-case or if-else code segments which may exist in the code. Based on the advantage, multi-person cooperation can exist in the game system, and a large number of configuration items can be added at the same time without editing a large number of codes.
Besides the configuration data management mode, the configuration of each module in the game can adopt the driving mode based on the configuration file. The specific configuration mode of the configuration items in the game can be written in the configuration file, and when the configuration items are newly added or reduced, any read-write and created code logic does not need to be modified, so that the usability and reusability of the game system are improved.
In some exemplary embodiments, the data units required by the behavior units may be loaded into the memory before the behavior units are created in the memory of the system based on the member methods corresponding to the behavior units.
Alternatively, the identity of the data units required by the system may be determined from the declaration information of the system. The declaration information of the system can be written in a code file of the system in a macro definition mode. And reading and analyzing the macro definition in the code file, so as to determine the identification of the data unit required by the system.
After the identifier of the data unit is obtained, the class description of the target class where the data unit is located can be determined according to the identifier of the data unit based on a reflection mechanism. In some embodiments, the operation of determining the class description of the second target class in which the data unit is located according to the identifier of the data unit may be implemented based on a getclassdescriptor (name) function. In this embodiment, the target class where the data unit is located is described as the second target class. Then, based on the reflection mechanism, the second target class in the resource file is accessed according to the class description of the second target class to obtain a data unit, and the data unit is loaded into the memory for use by the behavior unit.
When the system is implemented as a game system, the data unit can be implemented as a scene data unit of a game, and the scene data unit can be used by a scene management unit to implement a data management function of a game scene.
The operation of accessing the data unit in the second target class and loading the data unit into the memory according to the class description of the second target class may be implemented based on a pre-edited code template, where the code template includes a function (such as the enumerated function in the foregoing embodiment) for accessing the class based on the class description, and is used to implement access logic and loading logic for a certain variable. Wherein the value of the variable in the code template is externally accessible. After the data unit is determined from the second target class, the member variable corresponding to the data unit can be transmitted into the code template, that is, the variable in the code template is assigned according to the member variable corresponding to the data unit, so as to obtain a code for accessing and loading the data unit, and further, the access and loading of the data unit are realized.
Based on the above, after the behavior unit is created in the memory, the behavior unit may traverse the entity having the data unit of the specific type in the memory, and execute the corresponding function according to the data included in the traversed data unit. For example, after loading the mobile unit (Move unit) into the memory, the mobile unit may traverse all the Position type data units in the system through the reflection mechanism, and update the Position of the entity corresponding to the Position type data unit according to the Position data included in the Position type data unit.
In the method for loading the data unit, a reflection mechanism based on class description is adopted, so that the code template has extremely high reuse rate, the type of the class where the data unit is located does not need to be considered, and the access operation aiming at the data unit in any type of class can be completed.
In the embodiment of the present application, one behavior of the whole system determined by the external input data (i.e. configuration data) is represented as: the execution of each behavior unit in the system is determined by the attributes of the data unit. The behavior unit is based on the class description of the class, and after the data unit is found, whether the behavior unit is executed or not and how to execute the behavior unit can be judged according to the type of the data unit.
For example, for a mobile unit (Move unit), when performing a moving operation, it can be quickly determined whether a certain Object has a Position type data unit through a reflection mechanism. If yes, the Move unit can execute a moving operation on the object according to the position data in the data unit; otherwise, the Move unit does not perform the Move operation.
For another example, for a light-emitting unit, when a light-emitting operation is performed, the attribute of a light source data unit that a certain Object has can be quickly determined by a reflection mechanism. The attributes of the data cell of the light source may include: light source type (point light source, line light source), illumination distance, color, illumination angle, and the like. If the attribute of the light source data unit is: the light-emitting unit can perform the light-emitting operation of the red point light source, so that the object has the effect of emitting the red point light source. If the attribute of the light source data unit is: the light emitting unit can perform horizontal light emitting operation of the green line light source on the object so that the object has the effect of emitting the green horizontal illumination line light source.
In the embodiment of the present application, another behavior of the whole system determined by the external input data (i.e. configuration file) is represented as: how many behavior units are executed in the system is determined by external input data.
Based on the reflection mechanism, all behavioral units can be created and managed at runtime. The list of the required behavior units is stored in an external configuration file, namely the required behavior units can be dynamically created through the configuration file when the program instance is created, and further the initial state of the whole program instance is determined.
Further, by adding parameters for controlling the behavior unit, such as the size of the cache space required by the behavior unit, the thread number of the behavior unit, and the like, to the configuration file, the operation of the whole program can be controlled.
Based on the above, the behavior unit running in real time can be dynamically modified during the running period of the system by modifying the configuration file. Namely, according to the reflection mechanism based on the class description, the load balance of the system is dynamically adjusted. As will be exemplified below.
Optionally, the system or the device running the system may obtain real-time load data of the system, and display the real-time load data, so that the user may update the configuration file of the system according to the real-time load data; after the user updates the configuration file, the system can load or unload the designated behavior unit according to the updated configuration file, so as to dynamically adjust the behavior unit running in real time in the system. Furthermore, the method for adjusting the system load in real time during running is realized, and the healthy running of the system is facilitated.
Further, based on the class description and reflection mechanism, a runtime data editing method independent of the data structure can also be implemented, which will be exemplified below.
Optionally, in response to an editing operation by an editor, an identity of a data unit to be edited may be determined; wherein the identification of the data unit to be edited can be provided by an editing user. And then, according to the identification of the data unit to be edited, determining the class description of the target class where the data unit to be edited is located. For the sake of distinction, the class in which the data unit to be edited is located is described as the third target class hereinafter.
Then, based on the reflection mechanism, according to the class description of the third target class, the third target class in the resource file is accessed, and the member variable corresponding to the data unit to be edited is obtained from the third target class. And then, according to the member variable corresponding to the data unit to be edited, assigning the value to the editing object in the code template of the editor to obtain the editing code of the data unit to be edited. And operating the editing code of the data unit to be edited to generate an editing panel of the data unit to be edited, so that a user can edit the data unit to be edited.
In this way, when there is a need to edit a data unit, the data unit can be acquired based on the reflection mechanism by acquiring the class description of the class in which the data unit is located without paying attention to the structure of the data unit. On one hand, the code frame for generating the editing panel for the data unit can be reused for the data units with various different structures, so that the development cost is reduced; on the other hand, when the structure of the data unit changes, the mode of accessing the data unit is not affected, and the access efficiency is improved.
In this embodiment, all data units may be stored in a resource file of the system in JSON (JSON Object Notation) format. The resource file includes a class description (ClassDescriptor) name of each object, and values of each member variable in the class. Wherein, the values of the member variables in the class can be nested, i.e. the member variables themselves can also be a type corresponding to the ClassDescriptor.
Therefore, based on the class description of the third target class, when the member variable in the third target class is accessed, the type of the member variable can be further judged; and if the accessed member variable is of the basic data type, taking the accessed member variable as a member variable corresponding to the data unit to be edited, and directly generating an editing panel of the member variable.
If the accessed member variable is of a type of class description, the accessed member variable can be recursively traversed based on the class description of the accessed member variable until the member variable of the basic data type is accessed, the member variable is used as a member variable corresponding to the data unit to be edited, and an editing panel of the variable is generated for the member of the basic type.
Wherein, the basic type refers to the data type carried by the language tool, including: byte, short, int, long, float, double, char, bootean, pointer type, unsigned int, unsigned short, and so on.
That is, after reading an object from a resource file stored in the JSON format, the object may be traversed by a ClassDescriptor. In the process of traversing, for the member variable of each basic data type, a corresponding editing panel can be used; for member variables that are not of the underlying data type, this process may be performed recursively until all values are of the underlying data type. If the member variable is a non-basic type, the member variable can be considered to be nested with other types, and at the moment, recursive search can be carried out based on the ClassDescriptor until the values of all the searched member variables are basic types.
In this way, when the values of the member variables in the classes are nested, a reflection mechanism can be used to create corresponding editing panels for the member variables of the basic data types, and based on a recursive method, the member variables of the non-basic data structure can be edited, thereby avoiding the repeated writing of the editing panels for each class.
The process of generating an edit panel for a data unit generally comprises: reading data units from the resource file, storing the data units to the file in a serialization way, generating an editing interface and the like. The above process can be represented in pseudo code as:
based on the algorithm, all variables of non-fundamental data types can be processed recursively, and the process relies only on data at runtime. Furthermore, no matter serialization, deserialization and editor, only one set of basic code is needed to face the vast majority of data structure changes.
The following describes an exemplary data editing method using a reflection mechanism based on class description in conjunction with a game scenario.
The code template of the editor may be:
in the code template described above, the value of classType, which can be used to indicate the identity of the target class to be accessed, can be read from the configuration file of the game system. Any class is imported based on the code template of the editor, and the class can be decomposed into the granularity of ProcessBaseType () by recursively calling Process (), using ClassDescriptor of the reflection system.
For each class containing a data unit, the editor's code need not be modified even if the member variables in that class change. The operations of adding, deleting and modifying the member variables in the class can be directly mapped and processed into the ClassDescriptor by reflection operation without modifying the Process (). Similarly, any new type can be added, the Process () function can be directly called for processing, the editing function of the type can be completed without adding any new code, and the workload of the game editor and the workload of the post-maintenance editor are greatly reduced.
Further, the editing operation of the data is not directly dependent on the source code of the game engine. The editor code only depends on the ClassDescriptor, and the editor can work only by opening a ClassDescriptor header file and related data. After the editor is separated from the engine, the editor only needs to pay attention to the editing of the game data, and does not need to pay attention to the logic of the engine, so that the data driving is smoother.
On the basis of the above embodiments of the present application, if there is a need for a new behavior unit and a new data unit, it is only necessary to generate a class description for the new behavior unit or the new data unit and register the class description without rewriting a new code. As will be exemplified below.
Optionally, in response to the operation of the newly added behavior unit, a class description of a fourth target class of the newly added behavior unit may be obtained; next, the class description of the fourth target class is registered to update the registered class description in the source file. When the added behavior unit is subsequently accessed, the class description of the fourth target class can be acquired from the registered class descriptions, and the added behavior unit is accessed based on the class description of the fourth class. When the system is implemented as a game system, the added behavior unit may include a scene management unit.
Optionally, in response to the operation of adding the new data unit, a class description of a fifth target class in which the new data unit is located may be obtained; next, the class description of the fifth target class may be registered to update the registered class description in the source file. When subsequently accessing the newly added data unit, the class description of the fifth target class may be obtained from the registered class descriptions, and the newly added data unit may be accessed based on the class description of the fifth class. When the system is implemented as a game system, the newly added data unit may include a scene data unit. Based on the above embodiment, when a behavior unit or a data unit is newly added, the new addition can be realized without complex code editing, so that the development efficiency is greatly improved, and the development cost is reduced.
In some optional embodiments, the system modules can be freed from logical dependency by performing fine-grained splitting on the system. Optionally, when the system is subjected to fine-grained splitting, functional modules contained in the system can be determined; and then, splitting the functional module according to the sub-functions contained in the functional module to obtain behavior units corresponding to the sub-functions.
For example, taking a clipping (clipping) function module in a game system as an example, clipping is divided into a plurality of different clipping modes, such as quad tree clipping, octree clipping, view frustum clipping, and the like. According to each cutting mode, behavior units can be created, and each behavior unit can be used as a subsystem (subsystem) independently. When the system runs, the configuration cutting function module can contain one or more behavior units in the plurality of behavior units based on the configuration data.
Based on this embodiment, for each non-core functional module in the system, each implementation manner of the functional module may be packaged as one behavioral unit, and then, a three-layer structure of behavioral units (subsystems) - > functional modules- > system modules is formed.
Except for the core module, optionally, for the core module of the system, when the system runs, the functional module specifically included in the core module may also be configured by a configuration file, thereby implementing a running mode of the "data (configuration file)" system.
Taking a game system as an example, a core module (core module) of a game may include a plurality of functional modules such as asset management, thread management, rendering, and the like. The core system module specifically includes which functional modules, and can be configured by a configuration file. In some other embodiments, function modules such as a math module (math module), a scene module (scene module), an object pool module (object module), an editor module (editor module) and the like can be configured in the configuration file according to requirements.
The coupling degree between the functional modules is low, so that the functional requirements can be realized by combining different functional modules according to the requirements when the functional modules face different functional requirements. For example, in an editor scenario or a test scenario, an editor module or a debugging module is added to a core module through a configuration file to implement an editing function or a debugging function.
The mode of combining and managing the functional modules and the behavior units based on the configuration files realizes the driving of the system based on external data, avoids the modification of codes of the system, and reduces the development cost and the maintenance cost of the system. In addition, each subsystem obtained by splitting the system has higher independence, and the interdependence between the systems is only reflected on the data stream and does not exist in the system code. Besides the necessary basic system, some subsystems can be started and stopped dynamically according to the running load, and the flexibility is high.
It should be noted that the execution subjects of the steps of the methods provided in the above embodiments may be the same device, or different devices may be used as the execution subjects of the methods. For example, the execution subjects of steps 301 to 304 may be device a; for another example, the execution subject of steps 301 and 302 may be device a, and the execution subject of step 303 may be device B; and so on.
In addition, in some of the flows described in the above embodiments and the drawings, a plurality of operations are included in a specific order, but it should be clearly understood that the operations may be executed out of the order presented herein or in parallel, and the sequence numbers of the operations, such as 301, 302, etc., are merely used for distinguishing different operations, and the sequence numbers do not represent any execution order per se. Additionally, the flows may include more or fewer operations, and the operations may be performed sequentially or in parallel. It should be noted that, the descriptions of "first", "second", etc. in this document are used for distinguishing different messages, devices, modules, etc., and do not represent a sequential order, nor limit the types of "first" and "second" to be different.
Fig. 4 is a schematic structural diagram of an electronic device according to an exemplary embodiment of the present application, and as shown in fig. 4, the electronic device includes: a memory 401 and a processor 402.
The memory 401 is used for storing computer programs and may be configured to store other various data to support operations on the electronic device. Examples of such data include instructions for any application or method operating on the electronic device, contact data, phonebook data, messages, pictures, videos, and so forth.
The memory 401 may be implemented by any type or combination of volatile and non-volatile memory devices, such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disks.
The electronic device shown in fig. 4 is configured to execute a data-driven game system function loading method, where a source file of the system includes a plurality of classes, and each class has a class description; among the classes, the class for storing the behavior units and the class for storing the data units are decoupled from each other.
In performing the above system function loading method, the processor 402, coupled to the memory 401, is configured to execute the computer program in the memory 401 to: acquiring configuration data of a system, wherein the configuration data comprises an identifier of a behavior unit corresponding to a function to be loaded; determining a class description of a first target class corresponding to the identification of the behavior unit from the registered class descriptions based on a reflection mechanism; according to the class description of the first target class, inquiring member methods corresponding to the behavior units from the first target class; and calling a member method corresponding to the behavior unit, and creating the behavior unit in the memory of the system to execute the function.
Further optionally, before the processor 402 invokes the member method corresponding to the behavior unit and creates the behavior unit in the memory of the system, the processor is further configured to: determining the identification of the data unit required by the system according to the declaration information of the system; based on a reflection mechanism, determining the class description of the second target class where the data unit is located according to the identifier of the data unit; accessing the second target class in the resource file according to the class description of the second target class to obtain the data unit; and loading the data unit into a memory for use by the behavior unit to drive a function of the system based on the data unit.
Further optionally, the processor 402 is further configured to: responding to the editing operation of an editor, and determining the identification of the data unit to be edited; determining the class description of a third target class in which the data unit to be edited is located according to the identifier of the data unit to be edited; determining member variables corresponding to the data unit to be edited from the third target class according to the class description of the third target class based on a reflection mechanism; assigning values to the editing objects in the code template of the editor according to the member variables to obtain editing codes of the data units to be edited; and operating the editing codes of the data units to be edited, and generating an editing panel of the data units to be edited so that a user can edit the data units to be edited.
Further optionally, when determining, based on the reflection mechanism and according to the class description of the third target class, the member variable corresponding to the data unit to be edited from the third target class, the processor 402 is specifically configured to: accessing member variables in the third target class based on the class description of the third target class; if the type of the accessed member variable is the basic data type, taking the accessed member variable as a member variable corresponding to the data unit to be edited; if the accessed member variable is of the type of the class description, performing recursive traversal on the accessed member variable based on the class description of the accessed member variable until the member variable of the basic data type is accessed and is used as the member variable corresponding to the data unit to be edited.
Further optionally, the processor 402 is further configured to: responding to the operation of the newly added behavior unit, and acquiring the class description of a fourth target class in which the newly added behavior unit is located; and registering the class description of the fourth target class to update the registered class description so as to access the newly added behavior unit subsequently according to the class description of the fourth target class.
Further optionally, the processor 402 is further configured to: responding to the operation of the newly added data unit, and acquiring the class description of a fifth target class in which the newly added data unit is positioned; and registering the class description of the fifth target class to update the registered class description so as to access the newly added data unit according to the class description of the fifth target class subsequently.
Further optionally, the processor 402 is further configured to: acquiring real-time load data of the system; displaying the real-time load data so that a user can update the configuration data according to the real-time load data; and acquiring updated configuration data, and dynamically adjusting the behavior unit which runs in the system in real time according to the updated configuration data.
Further optionally, the processor 402 is further configured to: determining a functional module contained in the system; and splitting the functional module according to the sub-functions contained in the functional module to obtain behavior units corresponding to the sub-functions.
When the electronic device illustrated in fig. 4 is applied to a game scene, the system in this embodiment may be implemented as a game system, and the behavior unit may be implemented as a scene management unit in the game system, where the scene management unit may include: a binary tree scene management unit, a quad tree scene management unit, or an octree scene management unit. The data unit can be realized as a scene data unit in the game system, and is not described in detail.
Further, as shown in fig. 4, the electronic device further includes: display components 403, communication components 404, power components 405, audio components 406, and other components. Only some of the components are schematically shown in fig. 4, and the electronic device is not meant to include only the components shown in fig. 4.
Wherein the communication component 403 is configured to facilitate communication between the device in which the communication component is located and other devices in a wired or wireless manner. The device in which the communication component is located may access a wireless network based on a communication standard, such as WiFi, 2G, 3G, 4G, or 5G, or a combination thereof. In an exemplary embodiment, the communication component receives a broadcast signal or broadcast related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component may be implemented based on Near Field Communication (NFC) technology, Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, Ultra Wideband (UWB) technology, Bluetooth (BT) technology, and other technologies.
The display 404 includes a screen, which may include a Liquid Crystal Display (LCD) and a Touch Panel (TP), among others. If the screen includes a touch panel, the screen may be implemented as a touch screen to receive an input signal from a user. The touch panel includes one or more touch sensors to sense touch, slide, and gestures on the touch panel. The touch sensor may not only sense the boundary of a touch or slide action, but also detect the duration and pressure associated with the touch or slide operation.
The power supply module 405 provides power to various components of the device in which the power supply module is located. The power components may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power for the device in which the power component is located.
In this embodiment, a source file of the system includes a plurality of classes in which behavior units are stored, each class having a class description; when the function is loaded, the method decides which member methods in the classes are called to create the behavior unit according to the externally input data (namely, configuration data), and can determine the system operation logic based on the external data, thereby realizing the data driving of the system. On the premise that the behavior of the system is determined by externally input data, the operation behavior of the system can be changed by changing the externally input data, so that a new system function is realized, and the usability and reusability of the system are improved. In addition, in some embodiments, dynamic load balancing of the system may be achieved by modifying the configuration data. By matching with a reflection and data driving method, after the system is started, configuration data can be modified according to the load condition, and some behavior units or modules can be dynamically started and stopped, so that the load of the system is balanced.
Accordingly, the present application further provides a computer-readable storage medium storing a computer program, where the computer program is capable of implementing the steps that can be executed by the electronic device in the foregoing method embodiments when executed.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.
Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, a computer readable medium does not include a transitory computer readable medium such as a modulated data signal and a carrier wave.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
The above description is only an example of the present application and is not intended to limit the present application. Various modifications and changes may occur to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.
Claims (10)
1. A method for loading functions of a data-driven game system, wherein a source file of the game system comprises: a plurality of classes, each class having a class description; in the multiple classes, the class for storing the behavior unit and the class for storing the data unit are mutually decoupled; the method comprises the following steps:
acquiring configuration data of the game system, wherein the configuration data comprises an identifier of a scene management unit corresponding to a scene management function to be loaded;
determining a class description of a first target class corresponding to the identification of the scene management unit from the registered class descriptions based on a reflection mechanism;
according to the class description of the first target class, inquiring a member method corresponding to the scene management unit from the first target class;
and calling a member method corresponding to the scene management unit, and creating the scene management unit in a memory of the game system so as to drive a scene management function of the game system based on the configuration data.
2. The method of claim 1, wherein the scene management unit comprises: a binary tree scene management unit, a quad tree scene management unit, or an octree scene management unit.
3. The method of claim 1, wherein invoking the member method corresponding to the scenario management unit further comprises, before creating the scenario management unit in the memory of the game system:
determining an identification of a scene data unit required by the game system;
based on a reflection mechanism, determining a class description of a second target class in which the scene data unit is located according to the identifier of the scene data unit;
accessing the second target class in the resource file according to the class description of the second target class to obtain the scene data unit;
and loading the scene data unit into a memory for use by the scene management unit, so as to drive the scene management function of the game system based on the scene data unit.
4. The method of claim 1, further comprising:
responding to the editing operation of an editor, and determining the identifier of a scene data unit to be edited;
determining the class description of a third target class in which the scene data unit to be edited is located according to the identifier of the scene data unit to be edited;
determining member variables corresponding to the scene data unit to be edited from the third target class according to the class description of the third target class based on a reflection mechanism;
assigning values to the editing objects in the code template of the editor according to the member variables to obtain editing codes of the scene data units to be edited;
and operating the editing codes of the scene data units to be edited, and generating an editing panel of the scene data units to be edited so that a user can edit the scene data units to be edited.
5. The method according to claim 4, wherein determining the member variable corresponding to the scene data unit to be edited from the third target class according to the class description of the third target class based on a reflection mechanism comprises:
accessing member variables in the third target class based on the class description of the third target class;
if the type of the accessed member variable is a basic data type, taking the accessed member variable as a member variable corresponding to the scene data unit to be edited;
if the type of the accessed member variable is the type of the class description, performing recursive traversal on the accessed member variable based on the class description of the accessed member variable until the member variable of the basic data type is accessed and is used as the member variable corresponding to the scene data unit to be edited.
6. The method of claim 1, further comprising:
responding to the operation of the newly added scene management unit, and acquiring the class description of a fourth target class in which the newly added scene management unit is positioned;
and registering the class description of the fourth target class to update the registered class description so as to access the newly added scene management unit subsequently according to the class description of the fourth target class.
7. The method of claim 3, further comprising:
responding to the operation of newly adding a scene data unit, and acquiring the class description of a fifth target class in which the newly added scene data unit is positioned;
and registering the class description of the fifth target class to update the registered class description so as to access the newly added scene data unit subsequently according to the class description of the fifth target class.
8. The method of any one of claims 1-7, further comprising:
acquiring real-time load data of the game system;
displaying the real-time load data so that a user can update the configuration data according to the real-time load data;
and acquiring updated configuration data, and dynamically adjusting a scene management unit which runs in the game system in real time according to the updated configuration data.
9. An electronic device, comprising: a memory and a processor;
the memory is to store one or more computer instructions;
the processor is to execute the one or more computer instructions to: performing the steps of the method of any one of claims 1-8.
10. A computer-readable storage medium storing a computer program, wherein the computer program is capable of performing the steps of the method of any one of claims 1 to 8 when executed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011553075.4A CN112604273B (en) | 2020-12-24 | 2020-12-24 | Data-driven game system function loading method, device and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011553075.4A CN112604273B (en) | 2020-12-24 | 2020-12-24 | Data-driven game system function loading method, device and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112604273A true CN112604273A (en) | 2021-04-06 |
| CN112604273B CN112604273B (en) | 2021-08-24 |
Family
ID=75244847
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011553075.4A Active CN112604273B (en) | 2020-12-24 | 2020-12-24 | Data-driven game system function loading method, device and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112604273B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113191124A (en) * | 2021-05-20 | 2021-07-30 | 上海曼恒数字技术股份有限公司 | Runtime editing method and system based on 3D engine |
| WO2022134717A1 (en) * | 2020-12-24 | 2022-06-30 | 完美世界(北京)软件科技发展有限公司 | Data-driven system function loading method, device, and storage medium |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2018057606A (en) * | 2016-10-05 | 2018-04-12 | 株式会社コーエーテクモゲームス | Game processing program and information processing device |
| CN108159693A (en) * | 2017-12-05 | 2018-06-15 | 北京像素软件科技股份有限公司 | Scene of game construction method and device |
| CN111263924A (en) * | 2017-03-29 | 2020-06-09 | 苹果公司 | Device with integrated interface system |
| CN111857662A (en) * | 2020-07-15 | 2020-10-30 | 曹蕤 | Programming method for describing object specific constitution based on MAP and interface |
| CN111897596A (en) * | 2020-07-21 | 2020-11-06 | 珠海剑心互动娱乐有限公司 | Unity game resource loading optimization method and system |
| CN112023398A (en) * | 2020-06-23 | 2020-12-04 | 完美世界(北京)软件科技发展有限公司 | Game running method, device, equipment, system and storage medium |
-
2020
- 2020-12-24 CN CN202011553075.4A patent/CN112604273B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2018057606A (en) * | 2016-10-05 | 2018-04-12 | 株式会社コーエーテクモゲームス | Game processing program and information processing device |
| CN111263924A (en) * | 2017-03-29 | 2020-06-09 | 苹果公司 | Device with integrated interface system |
| CN108159693A (en) * | 2017-12-05 | 2018-06-15 | 北京像素软件科技股份有限公司 | Scene of game construction method and device |
| CN112023398A (en) * | 2020-06-23 | 2020-12-04 | 完美世界(北京)软件科技发展有限公司 | Game running method, device, equipment, system and storage medium |
| CN111857662A (en) * | 2020-07-15 | 2020-10-30 | 曹蕤 | Programming method for describing object specific constitution based on MAP and interface |
| CN111897596A (en) * | 2020-07-21 | 2020-11-06 | 珠海剑心互动娱乐有限公司 | Unity game resource loading optimization method and system |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2022134717A1 (en) * | 2020-12-24 | 2022-06-30 | 完美世界(北京)软件科技发展有限公司 | Data-driven system function loading method, device, and storage medium |
| CN113191124A (en) * | 2021-05-20 | 2021-07-30 | 上海曼恒数字技术股份有限公司 | Runtime editing method and system based on 3D engine |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112604273B (en) | 2021-08-24 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9934005B2 (en) | Dynamically building locale objects or subsections of locale objects based on historical data | |
| US10061573B2 (en) | User interfaces of application porting software platform | |
| JP5354602B2 (en) | Producer graph oriented programming and execution | |
| CN112604273B (en) | Data-driven game system function loading method, device and storage medium | |
| CN109144511B (en) | Method and system for automatically generating numerical simulation graphical user interface | |
| CN112256355B (en) | Data-driven system function loading method, equipment and storage medium | |
| CN113296786A (en) | Data processing method and device, electronic equipment and storage medium | |
| US20120159515A1 (en) | Sharing object representations | |
| US20210173641A1 (en) | Generation of knowledge graphs based on repositories of code | |
| CN110727482A (en) | Interface updating method and device | |
| US9141353B2 (en) | Dynamically building locale objects at run-time | |
| CN111159301A (en) | Data creating method, device, equipment and storage medium based on intelligent contract | |
| CN114185874A (en) | Big data based modeling method and device, development framework and equipment | |
| US20130346845A1 (en) | Interactive multi device in memory form generation | |
| KR20130068601A (en) | Apparatus and method for dynamic customization and execution of query based software logic for multitenant | |
| CN113342399A (en) | Application structure configuration method and device and readable storage medium | |
| CN112181407B (en) | Service realization processing method, device, system, electronic equipment and storage medium | |
| EP3834080B1 (en) | Static reconcilliation of application view hierarchies | |
| CN105393216B (en) | Run-time memory is adjusted | |
| US20210081184A1 (en) | Method and apparatus for enabling autonomous acceleration of dataflow ai applications | |
| US20180032929A1 (en) | Risk-adaptive agile software development | |
| US11449493B2 (en) | Persistent and configurable multidimensional data constraints | |
| US20090210384A1 (en) | Visualization of code units across disparate systems | |
| CN113296777A (en) | Dependency analysis and program compilation method, apparatus, and storage medium | |
| US9792093B2 (en) | Dynamically building subsections of locale objects at run-time |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| EE01 | Entry into force of recordation of patent licensing contract |
Application publication date: 20210406 Assignee: Beijing Xuanguang Technology Co.,Ltd. Assignor: Perfect world (Beijing) software technology development Co.,Ltd. Contract record no.: X2022990000254 Denomination of invention: Data driven game system function loading method, device and storage medium Granted publication date: 20210824 License type: Exclusive License Record date: 20220610 |
|
| EE01 | Entry into force of recordation of patent licensing contract |