Game table processing method, device, computer equipment and storage medium

Abstract

The embodiments of the present application disclose a method, apparatus, computer device, and storage medium for processing a game table. Applied to a data editor for a target game, the method comprises: obtaining mapping information of a game table library, wherein the game table library stores table data, and the mapping information is used to characterize the mapping relationship between the table data and the game code data; in response to a user's table selection operation, determining the name of the table selected by the user, wherein the name is used to identify the user-selected table; determining the game code data based on the mapping information; processing the game code data based on the mapping information to obtain first target data, wherein the first target data includes information to be modified in the user-selected text; and in response to the user's modification operation, modifying the first target data to obtain second target data. The method of the embodiments of the present application can omit the table import process and quickly and accurately obtain and modify table data.

Description

Technical Field

[0001] The present application relates to the field of game technology, and in particular to a game table processing method, apparatus, computer equipment, and storage medium. Background Art

[0002] In the game development process, the game planner completes the design of the tables required for the game. The designed game tables are imported into the game by the programmer. When necessary, the game tables can also be exported from the game. The process of importing or exporting game tables is called table importing.

[0003] However, importing a table requires running an import program. If the data in the game table needs to be adjusted, the game table must be re-exported to modify the data, and then the import operation must be performed through the import program. This process is cumbersome, time-consuming, and requires a high technical threshold, resulting in low efficiency in processing game tables. Summary of the Invention

[0004] The embodiments of the present application provide a game table processing method, apparatus, computer equipment, and storage medium, which can omit the table import process and quickly and accurately obtain and modify table data.

[0005] The present invention provides a method for processing a game table, the method comprising:

[0006] Acquire mapping information of a game table library, wherein the game table library stores table data, and the mapping information is used to represent a mapping relationship between the table data and the game code data;

[0007] In response to a table selection operation by the user, determining a name of the table selected by the user, wherein the name is used to identify the table selected by the user;

[0008] determining the game code data according to the mapping information;

[0009] Processing the game code data according to the mapping information to obtain first target data, wherein the first target data includes the information to be modified in the user-selected text;

[0010] In response to a modification operation by the user, the first target data is modified to obtain second target data.

[0011] The present application also provides a game table processing device, the device comprising:

[0012] A mapping information acquisition module, configured to acquire mapping information of a game table library, wherein the game table library stores table data, and the mapping information is used to represent a mapping relationship between the table data and the game code data;

[0013] a form determination module, in response to a form selection operation by a user, for determining a name of a form selected by the user, wherein the name is used to identify the form selected by the user;

[0014] a game code data determining module, configured to determine the game code data according to the mapping information;

[0015] A first target data acquisition module is configured to process the game code data according to the mapping information to obtain first target data, wherein the first target data includes the information to be modified in the user-selected text;

[0016] The second target data acquisition module is configured to modify the first target data to obtain second target data in response to a modification operation by a user.

[0017] Optionally, the game code data determination module may include:

[0018] a game code data determination submodule, configured to determine the game code data corresponding to the user-selected table based on the mapping information;

[0019] The game code data receiving submodule is used to request the table data from the client of the target game and receive the game code data.

[0020] Optionally, the game code data determination module may further include:

[0021] A game code data request submodule, configured to synchronously request the table data from the client and the second thread;

[0022] A first table data receiving submodule, configured to receive the first table data sent by the second thread;

[0023] The first target data optimization submodule is configured to perform an optimization operation on the first target data according to the first table data to obtain optimized first target data.

[0024] Optionally, the device further comprises:

[0025] A second target data sending submodule, configured to send a modification instruction of the second target data to the first thread pool of the target game;

[0026] The synchronous modification submodule is used to synchronously modify the first target data into game code data corresponding to the second target data through each first thread in the first thread pool.

[0027] Optionally, the synchronization modification submodule further includes:

[0028] a first synchronous modification submodule, configured to send the modification instruction to a first thread corresponding to the client, so as to modify the first target data stored in the client into the second target data;

[0029] The second synchronous modification submodule is used to send the modification instruction to the first thread corresponding to the server of the target game, so as to modify the first target data stored in the server into the game code data corresponding to the second target data.

[0030] Optionally, the second synchronization modification submodule is further specifically configured to:

[0031] Distributing the second target data to each first thread corresponding to the server, where the first thread is a thread other than the main thread of the server;

[0032] Each of the first threads parses the modification instruction to synchronously update the first target data stored in the server to the game code data corresponding to the second target data.

[0033] Optionally, the mapping information acquisition module is further specifically configured to:

[0034] Acquire first data of the table data, where the first data includes at least one of a name, a foreign key, a special field, a data type, and a table name;

[0035] Acquire game code data corresponding to the first data;

[0036] The mapping information is generated according to a mapping relationship between the first data and the game code data.

[0037] Optionally, the mapping information acquisition module is further specifically configured to:

[0038] Acquire the modified attribute data of the first target data;

[0039] The attribute data is organized into four-tuple data, and the four-tuple data is recorded as a modification instruction of the second target data.

[0040] An embodiment of the present application further provides a computer device comprising a processor and a memory, wherein the memory stores a plurality of instructions; the processor loads instructions from the memory to execute the steps in the game table processing method as described in any of the above embodiments.

[0041] The present application also provides a computer-readable storage medium storing a plurality of instructions suitable for loading by a processor to execute the steps of the game table processing method described in any of the above embodiments:

[0042] Acquire mapping information of a game table library, wherein the game table library stores table data, and the mapping information is used to represent a mapping relationship between the table data and the game code data;

[0043] In response to a table selection operation by the user, determining a name of the table selected by the user, wherein the name is used to identify the table selected by the user;

[0044] determining the game code data according to the mapping information;

[0045] Processing the game code data according to the mapping information to obtain first target data, wherein the first target data includes the information to be modified in the user-selected text;

[0046] In response to a modification operation by the user, the first target data is modified to obtain second target data.

[0047] As can be seen from the above, the embodiments of the present application can use mapping information to quickly obtain key data from table data via remote calls, and perform subsequent modification operations based on this key data, thereby further improving the efficiency of reading table data without affecting subsequent table data modification operations. The modified table data is also sent to the target game's thread pool via remote calls, and the thread pool's multiple threads can be used to synchronously modify the table data at multiple points. This can eliminate operations such as table import, game restart, game update, and game instruction modification, significantly improving the processing efficiency and effectiveness of game tables. BRIEF DESCRIPTION OF THE DRAWINGS

[0048] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present application. For those skilled in the art, other drawings can be obtained based on these drawings without creative work.

[0049] Figure 1 A system diagram of a game table processing device provided in an embodiment of the present application;

[0050] Figure 2 A flowchart of a game table processing method provided in an embodiment of the present application;

[0051] Figure 3 Another flowchart of the game table processing method provided in an embodiment of the present application;

[0052] Figure 4 A schematic diagram of the interaction between various terminals in the game table processing provided in an embodiment of the present application;

[0053] Figure 5A schematic diagram of each terminal synchronously modifying table data provided in an embodiment of the present application;

[0054] Figure 6 A schematic diagram of the interface of a game editor provided in an embodiment of the present application;

[0055] Figure 7 A schematic diagram of the structure of a game table processing device provided in an embodiment of the present application;

[0056] Figure 8 A schematic diagram of the structure of a computer device provided in an embodiment of the present application;

[0057] Figure 9 A program product that applies the game table processing method provided in an embodiment of the present application. DETAILED DESCRIPTION

[0058] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the embodiments described are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without making creative efforts are within the scope of protection of this application.

[0059] The terms "first," "second," and "third" in this application are used only for descriptive purposes and should not be understood as indicating or implying relative importance or implicitly indicating the number of the indicated technical features. Thus, a feature defined as "first," "second," or "third" may explicitly or implicitly include at least one of such features. In the description of this application, "multiple" means at least two, for example, two, three, etc., unless otherwise specifically defined. All directional indications in the embodiments of this application (such as up, down, left, right, front, back...) are only used to explain the relative positional relationship, movement, etc. between the components under a specific posture (as shown in the accompanying drawings). If the specific posture changes, the directional indications also change accordingly. In addition, the terms "including" and "having," as well as any variations thereof, are intended to cover non-exclusive inclusions. For example, a process, method, system, product, or device that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units that are not listed, or may optionally include other steps or units that are inherent to these processes, methods, products, or devices.

[0060] The embodiments of the present application provide a game table processing method, device, storage medium and computer equipment. Specifically, the game table processing method of the embodiments of the present application can be executed by a computer device, wherein the computer device can be a terminal or server device. The terminal can be a terminal device such as a smart phone, a tablet computer, a laptop computer, a touch screen, a game console, a personal computer (PC, Personal Computer), a personal digital assistant (Personal Digital Assistant, PDA), etc. The terminal device can also include a client, which can be a game application client, a browser client carrying a game program, or an instant messaging client, etc. The server can be an independent physical server, or a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, CDN, and basic cloud computing services such as big data and artificial intelligence platforms.

[0061] For example, when the game table processing method is run on a terminal, the terminal device stores a game application and presents part of the game scene in the game through a display component. The terminal device is used to interact with the user through a graphical user interface, for example, by downloading and installing a game application and running it through the terminal device. The terminal device may provide the graphical user interface to the user in a variety of ways, for example, it may be rendered and displayed on the display screen of the terminal device, or the graphical user interface may be presented through holographic projection. For example, the terminal device may include a touch screen and a processor, the touch screen being used to present the graphical user interface and receive operation instructions generated by the user acting on the graphical user interface, the graphical user interface including a game screen, and the processor being used to run the game, generate the graphical user interface, respond to operation instructions, and control the display of the graphical user interface on the touch screen.

[0062] For example, when the game table processing method is run on a server, it can be a cloud game. Cloud gaming refers to a gaming method based on cloud computing. In the cloud gaming operating mode, the operating body of the game application and the body that presents the game screen are separate. The storage and execution of the game table processing method are completed on the cloud gaming server. The game screen is presented on the cloud gaming client. The cloud gaming client is mainly used to receive and send game data and present the game screen. For example, the cloud gaming client can be a display device with data transmission capabilities close to the user, such as a mobile terminal, television, computer, PDA, personal digital assistant, etc., but the terminal device that executes the game table processing method is the cloud gaming server in the cloud. When playing the game, the user operates the cloud gaming client to send operation instructions to the cloud gaming server. The cloud gaming server runs the game according to the operation instructions, encodes and compresses the game screen and other data, and returns it to the cloud gaming client via the network. Finally, the cloud gaming client decodes and outputs the game screen.

[0063] See also Figure 1 , Figure 1 A system diagram of a display control device in a game provided by an embodiment of the present application. The system may include at least one terminal 1000, at least one server 2000, at least one database 3000, and a network 4000. The terminal 1000 held by a user can be connected to the servers of different games via the network 4000. The terminal 1000 is any device with computing hardware that can support and execute software products corresponding to the game. In addition, the terminal 1000 has one or more multi-touch screens for sensing and obtaining input from a user through touch or sliding operations performed at multiple points on one or more touch-sensitive display screens. In addition, when the system includes multiple terminals 1000, multiple servers 2000, and multiple networks 4000, different terminals 1000 can be connected to each other via different networks 4000 and different servers 2000. The network 4000 can be a wireless network or a wired network, such as a wireless network such as a wireless local area network (WLAN), a local area network (LAN), a cellular network, a 2G network, a 3G network, a 4G network, a 5G network, etc. Furthermore, different terminals 1000 can also connect to other terminals or servers using their own Bluetooth networks or hotspot networks. For example, multiple users can be online through different terminals 1000, thereby connecting and synchronizing with each other through appropriate networks to support multi-player gaming. Furthermore, the system may include multiple databases 3000, each coupled to different servers 2000, and capable of continuously storing information related to the gaming environment in the databases 3000 while different users are online playing a multi-player game.

[0064] An embodiment of the present application provides a method for processing a game table, which can be executed by a terminal or a server. This embodiment of the present application illustrates the method using a terminal as an example. The terminal includes a display component and a processor. The display component is configured to present a graphical user interface (GUI) and receive user-generated operational instructions generated by the display component. When a user operates the GUI via the display component, the GUI can control local content on the terminal or content on a peer server in response to the received operational instructions. For example, the operational instructions generated by the user operating the GUI include instructions for launching a game application. The processor is configured to launch the game application upon receiving the user-generated instruction to launch the game application. Furthermore, the processor is configured to render and draw a GUI associated with a game on a touchscreen display. The touchscreen display is a multi-touch-sensitive screen capable of sensing touch or slide operations performed simultaneously at multiple points on the screen. When a user performs a touch operation on the GUI with a finger, the GUI, upon detecting the touch operation, controls different game characters in the GUI to perform actions corresponding to the touch operation. For example, the game may be any of a casual game, an action game, a role-playing game, a strategy game, a sports game, a puzzle game, a first-person shooter (FPS), or the like. The game may include a game scene drawn on a graphical user interface. Furthermore, the game scene may include one or more game characters, such as a game character, controlled by a user (or player). Furthermore, the game scene may include one or more obstacles, such as railings, ravines, walls, etc., to restrict the movement of the game character, for example, restricting the movement of one or more objects to a specific area within the game scene. Optionally, the game scene may also include one or more elements, such as skills, scores, character health, energy, etc., to provide assistance to the player, provide virtual services, increase scores related to player performance, etc. Furthermore, the graphical user interface may also present one or more indicators to provide information to the player. For example, a game may include a player-controlled game character and one or more other game characters (such as enemy characters). In one embodiment, one or more other game characters are controlled by other players of the game. For example, one or more other game characters may be controlled by a computer, such as a robot using an artificial intelligence (AI) algorithm, to implement a human-computer game mode. For example, a game character may possess various skills or abilities that the game player can use to achieve goals. For example, a game character may possess one or more weapons, props, tools, etc. that can be used to eliminate other objects from the game. Such skills or abilities can be activated by the game player using one of a plurality of preset touch operations on the touch screen of the terminal.The processor may be configured to present a corresponding game screen in response to an operation instruction generated by a user's touch operation.

[0065] It should be noted that Figure 1 The system diagram of the game table processing device shown is only an example. The game table processing device and the scenario described in the embodiment of the present application are intended to more clearly illustrate the technical solution of the embodiment of the present application, and do not constitute a limitation on the technical solution provided by the embodiment of the present application. Ordinary technicians in this field can know that with the evolution of the game table processing device and the emergence of new business scenarios, the technical solution provided by the embodiment of the present application is also applicable to similar technical problems.

[0066] In this embodiment, the description will be made from the perspective of a display control device in a game. Specifically, the display control device in the game can be integrated into a computer device having a storage unit and a microprocessor installed therein and having computing capabilities.

[0067] See also Figure 2 , Figure 2 This is a flowchart of a game table processing method provided in an embodiment of the present application. The game table processing method includes the following steps:

[0068] Step 201: Obtain mapping information of the game table library.

[0069] The game table library may store table data. The table data in the embodiment of the present application may be game table data, which is stored in the game table and is used to represent values ​​or requirements in the game.

[0070] Virtual Characters Attack damage defense spider 5 10 Wolf 6 1

[0071] Table 1 - Attribute Table

[0072] Taking the game table Table 1 as an example, it can be seen that Table 1 reflects the game planner's requirements for the attack and defense attributes of the spider and wolf, while the values ​​5 and 6 corresponding to the attack power reflect the design of the specific values ​​of the virtual character's attack power by the game planner and technical personnel.

[0073] After confirming the table data, technical personnel need to write the corresponding game code data. For example, the game code data corresponding to the table "Spider's attack power is 5" in the table data can be:

[0074]

[0075] Among them, the attack power value 5 can be obtained through the game code data mapping.

[0076] The mapping information may be used to represent the mapping relationship between the table data and the game code data. It is understood that the mapping relationship may reflect the corresponding relationship between the table data and the game code data, for example, the table data "attack power" in Table 1 may correspond to the "atk" field in the game code data.

[0077] Optionally, step 201 may further include the following steps:

[0078] Acquire first data of the table data, where the first data includes at least one of a name, a foreign key, a special field, a data type, and a table name;

[0079] Acquire game code data corresponding to the first data;

[0080] The mapping information is generated according to a mapping relationship between the first data and the game code data.

[0081] Optionally, the mapping information may include mapping relationships between table data and game code data in terms of Chinese and English names, foreign keys, special characters, data type descriptions of individual attributes, and a list of data files corresponding to the game client.

[0082] To help understand how mapping information is generated, let's take the example of changing the spider's attack power in Table 1 from 5 to 6. You can select Table 1 in the game table library to obtain the corresponding mapping information, which includes three fields: def_sheet, primary_keys, and foreign_key. The def_sheet field contains a list of files storing all the game code data corresponding to Table 1. For example, "Attack Power" in Table 1 can be mapped to the attribute field under the def_sheet field using this mapping information.

[0083] Optionally, the def_sheet field of the mapping information can be specifically expressed as:

[0084] {

[0085] "def_sheet":{

[0086] "attribute":{

[0087] },

[0088] },

[0089] }

[0090] The def_sheet field represents a worksheet, that is, a game table field stored in the game client.

[0091] Among them, the mapping information file can not only save the Chinese names and basic attributes of the table data, but also save the corresponding English names and data types of the game code data.

[0092] Optionally, taking the attack power attribute in Table 1 as an example, the def_sheet field of the mapping information can be specifically expressed as:

[0093]

[0094] Among them, the Chinese name "attack power" of this attack power attribute can be mapped to the "atk" field of the name, meaning that the name of the game code data stored in the game client for the attack power attribute in Table 1 is atk. The data type type of this attack power attribute can be mapped to the "Int" format, meaning an integer, indicating that the attack power is reflected as an integer value in the game.

[0095] Optionally, the primary_keys field of the mapping information can be specifically expressed as:

[0096]

[0097] Among them, the primary_keys field is used to store the primary key of the table data, that is, the primary key of the table data can be mapped to the specific content "attribute ID" under the primary_keys field, which is the attribute identifier.

[0098] Optionally, the foreign_key field of the mapping information can be specifically expressed as:

[0099]

[0100] Among them, the foreign_key field is used to store the foreign key of the table data, that is, the foreign key "initial hatred value" field of the table data is indexed to the primary key "monster table.xlsx$monster".

[0101] Optionally, the mapping information can be obtained by preprocessing the game tables in the game table library. For example, the user can select a game table from the game table library, and the first program for performing the preprocessing operation can generate a mapping information file according to the correspondence between the table data and the game code data of the game table. It should be noted that after completing the operation of initially generating the mapping information file, when performing subsequent processing such as modifying and updating the table data corresponding to the mapping information file, the mapping information file can be directly called without performing the above preprocessing operation of generating the mapping information file again.

[0102] It should be noted that the table data in the embodiment of the present application may come from not only game tables but also other types of tables, such as work tables, cargo tables, etc. This embodiment does not limit the specific type of table to which the table data corresponds.

[0103] From the above, it can be seen that before processing the game table, the embodiment of the present application can pre-acquire the mapping information file to obtain the mapping relationship between the table data and the game code data, thereby significantly improving the efficiency of subsequently converting the game code data into table data from the client, thereby improving the overall efficiency of game table processing.

[0104] Step 202: In response to the user's table selection operation, determine the name of the table selected by the user.

[0105] The name is used to identify the user-selected table. Specifically, when a user wants to modify or update data in a table within a game table, the user can directly select the game table, for example, by clicking the cursor. The data editor then receives the selected game table as the user-selected table, and the name of the user-selected table is the file name of the table. For example, if the user selects Table 1, Table 1 is the user-selected table, and the name of Table 1 is "Attribute Table."

[0106] Step 203: Determine the game code data according to the mapping information.

[0107] It can be understood that from the perspective of the data editor, for the table data to be modified or updated, the corresponding game code data needs to be accurately determined from the client before the table data to be modified or updated can be accurately exported based on the game code data.

[0108] Optionally, step 203 may further include the following steps:

[0109] determining, based on the mapping information, the game code data corresponding to the user-selected table;

[0110] The table data is requested from a client of the target game, and the game code data is received.

[0111] Because the mapping information accurately reflects the relationship between table data and game code data, the data editor can accurately determine the corresponding game code data from the client based on this mapping information. For example, if we want to change the spider's attack power from 5 to 6 in Table 1, the data editor can use the mapping information to map the game code data to the client's name and atk fields.

[0112] Alternatively, the client may complete data transmission through a universal interface or protocol by way of an RPC (Remote Procedure Call) call.

[0113] See also Figure 4 , Figure 4 This is a schematic diagram of the interaction between the various terminals in the game table processing provided in the embodiment of the present application. Figure 4 As shown, data is transmitted between the game editor and the client, and between the client and the server through RPC calls, and data is transmitted between the game editor and the second thread through pipe communication, so that the entire game table processing flow of the embodiment of the present application does not need to rely on the table import program, and can realize the processes of table data loading, modification, importing and exporting, thereby improving the boundary and efficiency of game table processing.

[0114] It should be noted that the data editor of the embodiment of the present application can load tabular data through the GUI library of the QT framework to load different data structures, generate a modification interface based on the visual component, and be able to respond to the modification of the graphic component, thereby improving the intuitiveness and comprehensiveness of modifying the tabular data.

[0115] Step 204: Process the game code data according to the mapping information to obtain first target data.

[0116] It is understood that after obtaining the mapping information and game code data, the game code data can be directly converted into corresponding table data in the data editor. For example, the name field and atk field of the client game code data can be converted into table data with the name of spider and the attribute of attack power.

[0117] The first target data may include key data in the table data. It is understood that since the mapping information is used to represent the mapping relationship between the table data and several key data items in the game code data, the first target data obtained by converting the game code data through the mapping relationship is not the original table data, but rather includes key data in the table data, such as name, attributes, primary key, foreign key, etc., while some unimportant data in the table data, such as annotation information, data format, and field display order, may not be loaded temporarily.

[0118] See also Figure 6 , Figure 6 This is a schematic diagram of the interface of the game editor provided in the embodiment of the present application. Figure 6 As shown, in the interface of the data editor, the attribute table's attribute ID, primary key, virtual role name, attribute value and other data are clearly displayed.

[0119] As can be seen from the above, the embodiments of the present application can quickly and accurately obtain the first target data converted from the game code data, which is used to represent the key data in the table data, and perform subsequent modification operations based on this first target data, thereby further improving the efficiency of reading the table data without affecting the subsequent table data modification operations. In actual application, the data editor obtains the first target data in this way, and compared with traditional table import operations, the time to obtain table data can be significantly reduced from about 15 seconds to about 2 seconds.

[0120] Optionally, the embodiment of the present application may further include the following steps:

[0121] synchronously requesting the table data from the client and the second thread;

[0122] receiving first table data sent by the second thread;

[0123] An optimization operation is performed on the first target data according to the first table data to obtain optimized first target data.

[0124] The second thread may be an Excel thread. Figure 3 As shown, the data editor can simultaneously request the form data from the second thread while requesting the form data from the client.

[0125] It is understandable that since the Excel thread opens the table data at a slow speed, the client will usually obtain the first target data by the above-mentioned method of processing the game code data with mapping information before the Excel thread opens the table data, and perform the table data modification operation based on the first target data. The first table data opened by the Excel thread is the original table data, that is, the original data in the table selected by the user. After the data editor presents the first target data, it can also perform optimization operations on the first target data based on the first table data to obtain the optimized first target data. For example, the optimization operation may include adding annotation information to the first target data, adjusting the data format, display order, and adding non-critical data that does not exist in the first target data.

[0126] As can be seen from the above, the embodiments of the present application can not only quickly and accurately display key data in the table data using the first target data, but also directly modify the first target data later. Furthermore, after the first target data is loaded, the first table data can be used to optimize the first target data so that the data editor can better display the table data, thereby comprehensively improving the efficiency and effectiveness of processing the game table.

[0127] Step 205: In response to the user's modification operation, modify the first target data to obtain second target data.

[0128] Specifically, to facilitate understanding of the process of modifying the first target data to obtain the second target data, let's continue with the example of changing the spider's attack power from 5 to 6. Since the spider's attack power attribute is stored in Table 1 - Attribute Table, the game code data sent by the client to the game editor can be expressed as:

[0129]

[0130] As can be seen, the game code data reflects that the spider's attack power in Table 1 is 5 and the wolf's attack power is 6. Before performing the table data modification operation, the data editor can use the mapping information to determine that the atk field corresponds to the "attack power" in the table data, the name field corresponds to the "virtual character" in the table data, and the primary_keys field corresponds to the primary key "attribute ID" in the table data. Attribute ID 1 corresponds to the spider, and attribute ID 2 corresponds to the wolf. The first target data in the data editor can be initially displayed as follows:

[0131]

[0132]

[0133] Furthermore, the user can select the row data of the first row of the attribute ID and display another portion of the first target data through the attribute window of the data editor. The row data can be displayed in the data editor as follows:

[0134] Property ID 1 name spider Attack damage 5

[0135] Furthermore, when modifying, the user only needs to change the value 5 corresponding to the attack power to 6 through the editor. The modified table data, that is, the second target data, can be expressed as:

[0136] Property ID 1 name spider Attack damage 6

[0137] It can be seen that the data editor can better display the row data in the table data in response to the user's selection operation, so that the user can focus more on modifying the row data of each row. In addition, the second target data can also be reflected in the game table in an incremental write-back manner. Specifically, after modifying the data, the difference between the retained data and the original data is compared and stored. After clicking the Save button on the data editor side, the stored second target data is organized into a two-tuple (primary key, row data), and the two-tuple data is transmitted to any Excel thread through pipeline communication. After processing, the Excel thread creates a new table and writes the processed second target data into the new table. The table data of the original game table is written in the table as reference data to support game planners to correct the table data. After confirming that the data is correct, the planner can copy the entire row of second target data back to the original table.

[0138] Optionally, step 205 may further include the following steps:

[0139] Acquire the modified attribute data of the first target data;

[0140] The attribute data is organized into four-tuple data, and the four-tuple data is recorded as a modification instruction of the second target data.

[0141] The attribute data may be a game modification instruction readable by the client. Specifically, the attribute data may be assembled into a client-readable quad-tuple, and the quad-tuple may be used as the second target data. The quad-tuple may include a file name, a primary key, a modified field, and a modified value corresponding to the modified game code data.

[0142] Alternatively, continuing the above example, the quadruple can be specifically expressed as:

[0143] ("attribute",1,"atk",6)

[0144] It can be understood that after the quadruple is sent to the client, the client can effectively modify the corresponding game code data according to the modification instruction by parsing the quadruple. The modified game code data can be expressed as:

[0145]

[0146] Optionally, the embodiment of the present application may further include the following steps:

[0147] Sending a modification instruction of the second target data to the first thread pool of the target game;

[0148] The first target data is synchronously modified into game code data corresponding to the second target data through each first thread in the first thread pool.

[0149] See also Figure 5 , Figure 5 This is a schematic diagram of each terminal synchronously modifying table data provided in the embodiment of this application. Figure 5 As shown, the client and server of the embodiment of the present application can modify the game code data through multi-threading of the thread pool, thereby improving the efficiency of data modification.

[0150] Optionally, the step of “synchronously modifying the first target data to game code data corresponding to the second target data” includes:

[0151] Sending the modification instruction to a first thread corresponding to the client to modify the first target data stored in the client to the second target data;

[0152] The modification instruction is sent to a first thread corresponding to a server of the target game, so as to modify the first target data stored in the server into game code data corresponding to the second target data.

[0153] like Figure 5 As shown, after the data editor completes the table data modification operation, the modification instruction, namely the quad-tuple data, can be sent to the client. The client then starts a first thread in the first thread pool to process the data modification, thereby achieving asynchronous modification. Accordingly, after the client completes the data modification operation, the quad-tuple data can be uploaded to the server, so that the server can also complete the table data modification operation based on the modification instruction of the quad-tuple data. This eliminates the traditional operation of sequentially copying the modified game code data to the server, thereby greatly improving data modification efficiency.

[0154] Optionally, the step of “modifying the first target data stored in the server into the second target data” includes:

[0155] Distributing the second target data to each first thread corresponding to the server, where the first thread is a thread other than the main thread of the server;

[0156] Each of the first threads parses the modification instruction to synchronously update the first target data stored in the server to the game code data corresponding to the second target data.

[0157] It can be understood that performing data modifications based on multiple first threads outside the main thread not only enables highly efficient multi-point data modification operations, but also effectively completes data modification operations without affecting the operation of the target game server's main process. In practical applications, compared to the traditional method of hot-updating modified game code data, the method of this embodiment not only achieves the effect of synchronously modifying data on multiple terminals through a single modification operation, but also reduces the time required to fully modify table data and game code data from approximately 3 minutes to approximately 1 second.

[0158] As can be seen from the above, the embodiments of the present application can use mapping information to quickly obtain key data from table data via remote calls, and perform subsequent modification operations based on this key data, thereby further improving the efficiency of reading table data without affecting subsequent table data modification operations. The modified table data is also sent to the target game's thread pool via remote calls, and the thread pool's multiple threads can be used to synchronously modify the table data at multiple points. This can eliminate operations such as table import, game restart, game update, and game instruction modification, significantly improving the processing efficiency and effectiveness of game tables.

[0159] See also Figure 3 , Figure 3 This is another flowchart of the game table processing method provided in an embodiment of the present application. The specific process of this method can be as follows:

[0160] Step 301: Issue a mapping information generation request;

[0161] Step 302: pre-process the data using a first program;

[0162] Step 303: Obtain mapping information;

[0163] Step 304: Determine the user selected form;

[0164] Step 305: Send a data acquisition request to the client and the second process simultaneously;

[0165] Step 306: Obtain game code data;

[0166] Step 307: Obtain table data according to the mapping information;

[0167] Step 308: display the first target data;

[0168] Step 309: Obtain table data;

[0169] Step 310: Optimize and display the first target data;

[0170] Step 311: Modify the first target data to obtain the second target data;

[0171] Step 312: Send the modification instruction to the client;

[0172] Step 313: The client performs an asynchronous modification operation.

[0173] Step 314: The server performs a multi-threaded synchronous modification operation.

[0174] In order to better implement the above method, the present application embodiment also provides a game table processing device, please refer to Figure 7 , Figure 7 This is a schematic diagram of the structure of a game table processing device provided in an embodiment of the present application. The device should be applied to a data editor of a target game. The device may include:

[0175] The mapping information acquisition module 401 may be used to acquire mapping information of a game table library. The game table library stores table data. The mapping information is used to represent the mapping relationship between the table data and the game code data.

[0176] The form determination module 402 may be used to determine the name of the form selected by the user in response to the form selection operation of the user, where the name is used to identify the form selected by the user;

[0177] The game code data determination module 403 may be used to determine the game code data according to the mapping information;

[0178] The first target data acquisition module 404 may be used to process the game code data according to the mapping information to obtain first target data, wherein the first target data includes the information to be modified in the text selected by the user;

[0179] The second target data acquisition module 405 can be used to modify the first target data to obtain the second target data in response to a user's modification operation.

[0180] Optionally, the game code data determination module 403 may include:

[0181] The game code data determination submodule can be used to determine the game code data corresponding to the table selected by the user based on the mapping information;

[0182] The game code data receiving submodule can be used to request table data from the client of the target game and receive game code data.

[0183] Optionally, the game code data determination module 403 may further include:

[0184] The game code data request submodule can be used to synchronously request table data from the client and the second thread;

[0185] The first table data receiving submodule can be used to receive the first table data sent by the second thread;

[0186] The first target data optimization submodule can be used to perform an optimization operation on the first target data according to the first table data to obtain optimized first target data.

[0187] Optionally, the device may further include:

[0188] The second target data sending submodule can be used to send the modification instruction to the first thread pool of the target game;

[0189] The synchronous modification submodule can be used to synchronously modify the first target data into game code data corresponding to the second target data through each first thread in the first thread pool.

[0190] Optionally, the synchronization modification submodule may further include:

[0191] The first synchronous modification submodule may be used to send a modification instruction to the first thread corresponding to the client, so as to modify the first target data stored in the client into the game code data corresponding to the second target data;

[0192] The second synchronous modification submodule can be used to send a modification instruction to the first thread corresponding to the server of the target game to modify the first target data stored in the server into game code data corresponding to the second target data.

[0193] Optionally, the second synchronization modification submodule may be further specifically configured to:

[0194] Distributing the second target data to each first thread corresponding to the server, where the first thread is a thread other than the main thread of the server;

[0195] Each first thread parses the second target data to synchronously update the first target data stored in the server to the second target data.

[0196] Optionally, the mapping information acquisition module 401 may also be specifically configured to:

[0197] Acquire first data of the table data, where the first data includes at least one of a name, a foreign key, a special field, a data type, and a table name;

[0198] Acquire game code data corresponding to the first data;

[0199] The mapping information is generated according to the mapping relationship between the first data and the game code data.

[0200] Optionally, the mapping information acquisition module 401 may also be specifically configured to:

[0201] Acquire the modified attribute data of the first target data;

[0202] The attribute data is organized into quadruple data, and the quadruple data is recorded as the second target data.

[0203] In specific implementation, the above units can be implemented as independent entities, or can be arbitrarily combined to be implemented as the same or several entities. The specific implementation of the above units can be found in the previous method embodiments and will not be repeated here.

[0204] The game table processing device provided in the embodiment of the present application obtains mapping information of a game table library through a mapping information acquisition module 401, then determines the name of the table selected by the user in response to a table selection operation by the user through a table determination module 402, and then determines the game code data based on the mapping information through a game code data determination module 403; then, processes the game code data based on the mapping information through a first target data acquisition module 404 to obtain first target data; and finally, modifies the first target data in response to a modification operation by the user through a second target data acquisition module 405 to obtain second target data.

[0205] As can be seen from the above, the embodiments of the present application can use mapping information to quickly obtain key data from table data via remote calls, and perform subsequent modification operations based on this key data, thereby further improving the efficiency of reading table data without affecting subsequent table data modification operations. The modified table data is also sent to the target game's thread pool via remote calls, and the thread pool's multiple threads can be used to synchronously modify the table data at multiple points. This can eliminate operations such as table import, game restart, game update, and game instruction modification, significantly improving the processing efficiency and effectiveness of game tables.

[0206] Accordingly, an embodiment of the present application also provides a computer device, which may be a terminal or a server, and the terminal may be a smart phone, tablet computer, laptop computer, touch screen, game console, personal computer, personal digital assistant (PDA) and other terminal devices.

[0207] like Figure 8 As shown, Figure 8This is a schematic diagram of the structure of a computer device provided in an embodiment of the present application. The computer device 500 includes a processor 501 having one or more processing cores, a memory 502 having one or more computer-readable storage media, and a computer program stored in the memory 502 and executable on the processor. The processor 501 is electrically connected to the memory 502. Those skilled in the art will appreciate that the computer device structure shown in the figure does not limit the computer device and may include more or fewer components than shown, or combine certain components, or arrange the components differently.

[0208] The processor 501 is the control center of the computer device 500. It uses various interfaces and lines to connect various parts of the entire computer device 500. By running or loading software programs and / or modules stored in the memory 502 and calling data stored in the memory 502, it executes various functions of the computer device 500 and processes data, thereby monitoring the computer device 500 as a whole.

[0209] In the embodiment of the present application, the processor 501 in the computer device 500 loads instructions corresponding to one or more application processes into the memory 502 according to the following steps, and the processor 501 runs the application stored in the memory 502 to implement various functions:

[0210] Obtain mapping information of a game table library, where the game table library stores table data, and the mapping information is used to represent a mapping relationship between the table data and the game code data;

[0211] In response to a table selection operation by the user, determining a name of the table selected by the user, the name being used to identify the table selected by the user;

[0212] Determine the game code data according to the mapping information;

[0213] Processing the game code data according to the mapping information to obtain first target data, wherein the first target data includes information to be modified in the text selected by the user;

[0214] In response to a modification operation by the user, the first target data is modified to obtain second target data.

[0215] As can be seen, the embodiments of the present application can use mapping information to quickly obtain key data from table data via remote calls, and perform subsequent modification operations based on this key data, thereby further improving the efficiency of reading table data without affecting subsequent table data modification operations. The modified table data is also sent to the target game's thread pool via remote calls, and the thread pool's multiple threads can be used to synchronously modify the table data at multiple points. This can omit operations such as table import, game restart, game update, and game instruction modification, significantly improving the processing efficiency and effectiveness of game tables.

[0216] The specific implementation of the above operations can be found in the previous embodiments and will not be repeated here.

[0217] Optional, such as Figure 8 As shown, the computer device 500 further includes: a touch screen 503, a radio frequency circuit 504, an audio circuit 505, an input unit 506, and a power supply 507. Among them, the processor 501 is electrically connected to the touch screen 503, the radio frequency circuit 504, the audio circuit 505, the input unit 506, and the power supply 507 respectively. It can be understood by those skilled in the art that Figure 8 The computer device structure shown in the figure does not constitute a limitation to the computer device, and may include more or fewer components than shown in the figure, or combine certain components, or arrange the components differently.

[0218] The touch display screen 503 can be used for displaying a graphical user interface and receiving the operation instructions that the user acts on the graphical user interface. The touch display screen 503 can include a display panel and a touch panel. Wherein, the display panel can be used for displaying the information input by the user or the information provided to the user and the various graphical user interfaces of the computer device, and these graphical user interfaces can be composed of graphics, text, icons, videos and any combination thereof. Optionally, the display panel can be configured using forms such as a liquid crystal display (LCD, Liquid Crystal Display), an organic light emitting diode (OLED, Organic Light-Emitting Diode). The touch panel can be used for collecting the user's touch operation thereon or near it (such as the user uses any suitable object or attachment such as a finger, a stylus on the touch panel or near the touch panel), and generates corresponding operation instructions, and the operation instruction executes corresponding program. Optionally, the touch panel can include two parts: a touch detection device and a touch controller. Among them, the touch detection device detects the user's touch direction, detects the signal brought by the touch operation, and transmits the signal to the touch controller; the touch controller receives the touch information from the touch detection device, converts it into the touch point coordinates, and then sends it to the processor 501, and can receive the command sent by the processor 501 and execute it. The touch panel can cover the display panel. When the touch panel detects a touch operation on or near it, it is transmitted to the processor 501 to determine the type of touch event, and then the processor 501 provides a corresponding visual output on the display panel according to the type of touch event. In an embodiment of the present application, the touch panel and the display panel can be integrated into the touch display screen 503 to realize input and output functions. However, in some embodiments, the touch panel and the touch panel can be used as two independent components to realize input and output functions. That is, the touch display screen 503 can also be used as part of the input unit 506 to realize the input function.

[0219] In this embodiment of the present application, processor 501 executes a game application to generate a graphical user interface (GUI) on touchscreen display 503. The game scene on the GUI includes at least one skill control area, which includes at least one skill control. Touchscreen display 503 is used to present the GUI and receive user commands generated by operating the GUI.

[0220] The radio frequency circuit 504 may be used to transmit and receive radio frequency signals, so as to establish wireless communication with a network device or other computer device through wireless communication, and to transmit and receive signals between the network device or other computer device.

[0221] Audio circuit 505 can be used to provide an audio interface between the user and the computer device through a speaker and microphone. Audio circuit 505 can convert received audio data into electrical signals and transmit them to the speaker, which then converts them into sound signals for output. Conversely, the microphone converts collected sound signals into electrical signals, which are then received by audio circuit 505 and converted into audio data. The audio data is then output to processor 501 for processing, then transmitted via RF circuit 504 to, for example, another computer device, or to memory 502 for further processing. Audio circuit 505 may also include an earphone jack to allow communication between external headphones and the computer device.

[0222] The input unit 506 may be configured to receive input digital, character information, or user feature information (such as fingerprint, iris, or facial information), and to generate keyboard, mouse, joystick, optical, or trackball signal inputs related to user settings and function control.

[0223] Power supply 507 is used to supply power to various components of computer device 500. Optionally, power supply 507 can be logically connected to processor 501 via a power management system, thereby enabling the power management system to manage charging, discharging, and power consumption. Power supply 507 can also include one or more DC or AC power supplies, a recharging system, a power failure detection circuit, a power converter or inverter, a power status indicator, and other arbitrary components.

[0224] although Figure 8 Not shown in the figure, the computer device 500 may also include a camera, a sensor, a wireless fidelity module, a Bluetooth module, etc., which will not be described in detail here.

[0225] In the above embodiments, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0226] As can be seen from the above, the embodiments of the present application can use mapping information to quickly obtain key data from table data via remote calls, and perform subsequent modification operations based on this key data, thereby further improving the efficiency of reading table data without affecting subsequent table data modification operations. The modified table data is also sent to the target game's thread pool via remote calls, and the thread pool's multiple threads can be used to synchronously modify the table data at multiple points. This can eliminate operations such as table import, game restart, game update, and game instruction modification, significantly improving the processing efficiency and effectiveness of game tables.

[0227] Those skilled in the art will appreciate that all or part of the steps in the various methods of the above embodiments may be accomplished by instructions, or by controlling related hardware through instructions. The instructions may be stored in a computer-readable storage medium and loaded and executed by a processor.

[0228] To this end, an embodiment of the present application provides a computer-readable storage medium storing a plurality of computer programs, which can be loaded by a processor to execute the steps of any of the game table processing methods provided in the embodiments of the present application. For example, the computer program can execute the following steps:

[0229] Obtain mapping information of a game table library, where the game table library stores table data, and the mapping information is used to represent a mapping relationship between the table data and the game code data;

[0230] In response to a table selection operation by the user, determining a name of the table selected by the user, the name being used to identify the table selected by the user;

[0231] Determine the game code data according to the mapping information;

[0232] Processing the game code data according to the mapping information to obtain first target data, wherein the first target data includes information to be modified in the text selected by the user;

[0233] In response to a modification operation by the user, the first target data is modified to obtain second target data.

[0234] The specific implementation of the above operations can be found in the previous embodiments and will not be repeated here.

[0235] The storage medium may include a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk, etc.

[0236] Since the computer program stored in the storage medium can execute the steps of any game table processing method provided in the embodiments of the present application, the beneficial effects that can be achieved by any game table processing method provided in the embodiments of the present application can be achieved. Please refer to the previous embodiments for details and will not be repeated here.

[0237] refer to Figure 9As shown, a program product 61 for implementing the above-mentioned method according to an embodiment of the present invention is described. The program product 61 may be a portable compact disc read-only memory (CD-ROM) and includes program code, and can be run on a terminal device, such as a personal computer. However, the program product of the present invention is not limited thereto. In this document, a readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device.

[0238] The program product can be implemented in any combination of one or more readable media. The readable medium can be a readable signal medium or a readable storage medium. The readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or component, or any combination thereof. More specific examples of readable storage media (a non-exhaustive list) include: an electrical connection with one or more wires, a portable disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof.

[0239] A computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, which carries readable program code. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A readable signal medium may also be any readable medium other than a readable storage medium that can transmit, propagate, or transfer a program for use by or in conjunction with an instruction execution system, apparatus, or device.

[0240] The program code embodied on the readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

[0241] The program code for performing the operations of the present invention may be written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java, C++, and the like, as well as conventional procedural programming languages ​​such as "C" or similar programming languages. The program code may be executed entirely on the user computing device, partially on the user device, as a stand-alone software package, partially on the user computing device and partially on a remote computing device, or entirely on a remote computing device or server. In cases involving a remote computing device, the remote computing device may be connected to the user computing device via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computing device (e.g., via the Internet using an Internet service provider).

[0242] The above is a detailed introduction to a game table processing method, device, storage medium and computer equipment provided in the embodiments of the present application. Specific examples are used herein to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method and core ideas of the present application. At the same time, for those skilled in the art, based on the ideas of the present application, there may be changes in the specific implementation methods and application scope. In summary, the content of this specification should not be understood as limiting the present application.

Claims

1. A game table processing method, characterized in that: The method applied to the data editor of the target game includes: Acquire mapping information of a game table library, wherein the game table library stores table data, and the mapping information is used to represent a mapping relationship between the table data and the game code data; In response to a table selection operation by the user, determining a name of the table selected by the user, wherein the name is used to identify the table selected by the user; Determining the game code data by remote calling according to the mapping information; Processing the game code data according to the mapping information to obtain first target data, wherein the first target data includes the information to be modified in the user-selected text; In response to a modification operation by a user, modifying the first target data to obtain second target data; Sending a modification instruction of the second target data to the first thread pool of the target game; The first target data stored in the server is synchronously modified to the game code data corresponding to the second target data through each first thread in the first thread pool.

2. The game table processing method according to claim 1, wherein: Determining the game code data by remote calling according to the mapping information includes: determining, based on the mapping information, the game code data corresponding to the user-selected table; The table data is requested from a client of the target game, and the game code data is received.

3. The game table processing method according to claim 2, wherein: The method further comprises: synchronously requesting the table data from the client and the second thread; receiving first table data sent by the second thread; An optimization operation is performed on the first target data according to the first table data to obtain optimized first target data.

4. The game table processing method according to claim 1, wherein: The step of synchronously modifying the first target data stored in the server to the game code data corresponding to the second target data includes: Sending the modification instruction to a first thread corresponding to the client to modify the first target data stored in the client to the second target data; The modification instruction is sent to a first thread corresponding to the server of the target game, so as to modify the first target data stored in the server into game code data corresponding to the second target data.

5. The game table processing method according to claim 4, characterized in that: The modifying the first target data stored in the server to the second target data includes: Distributing the second target data to each first thread corresponding to the server, where the first thread is a thread other than the main thread of the server; Each of the first threads parses the modification instruction to synchronously update the first target data stored in the server to the game code data corresponding to the second target data.

6. The game table processing method according to claim 1, wherein: The step of obtaining the mapping information of the game table library includes: Acquire first data of the table data, where the first data includes at least one of a name, a foreign key, a special field, a data type, and a table name; Acquire game code data corresponding to the first data; The mapping information is generated according to a mapping relationship between the first data and the game code data.

7. The game table processing method according to claim 1, wherein: The modifying the first target data to obtain the second target data includes: Acquire the modified attribute data of the first target data; The attribute data is organized into four-tuple data, and the four-tuple data is recorded as a modification instruction of the second target data.

8. A game table processing device, characterized in that: The device comprises: A mapping information acquisition module, configured to acquire mapping information of a game table library, wherein the game table library stores table data, and the mapping information is used to represent a mapping relationship between the table data and the game code data; a form determination module, in response to a form selection operation by a user, for determining a name of a form selected by the user, wherein the name is used to identify the form selected by the user; A game code data determination module, configured to determine the game code data by remote calling according to the mapping information; A first target data acquisition module is configured to process the game code data according to the mapping information to obtain first target data, wherein the first target data includes the information to be modified in the user-selected text; a second target data acquisition module, configured to modify the first target data to obtain second target data in response to a modification operation by a user; A second target data sending submodule, configured to send the modification instruction to the first thread pool of the target game; The synchronous modification submodule is used to synchronously modify the first target data into game code data corresponding to the second target data through each first thread in the first thread pool.

9. A computer device, characterized in that: The system comprises a processor and a memory, wherein the memory stores a plurality of instructions; the processor loads instructions from the memory to execute the steps of the game table processing method according to any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a plurality of instructions, and the instructions are suitable for being loaded by a processor to execute the steps of the game table processing method according to any one of claims 1 to 7.

Images