A method and device for implementing game self-service

Abstract

The present application discloses a method and device for implementing game self-service. The embodiment of the present application receives a self-service request sent by a target game self-service tool through a universal self-service tool interface, and the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in a terminal. The self-service request is parsed based on the interface specification file of the universal self-service tool interface to obtain request parameters. According to the request parameters, the service response data corresponding to the target user in the target game is obtained. The service response data is converted into target service response data that conforms to the interface specification file. The target service response data is sent to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data. The present application can uniformly maintain and configure multiple game self-service tools through the universal self-service tool interface, shortening the development cycle of game self-service tools and reducing enterprise operating costs.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a method and device for implementing game self-service. Background Art

[0002] With the development of computer technology, various games have gradually become popular in people's lives, and the number of game players has continued to increase. In the field of game services, the various problems and demands of game players are also increasing day by day.

[0003] In the current related technologies, game players can generally seek solutions by reporting existing problems and needs to customer service staff, but this requires a lot of manpower and material resources, greatly increasing the company's operating costs. Summary of the Invention

[0004] The embodiments of the present application provide a method and device for implementing game self-service, which can shorten the development cycle of game self-service tools and reduce enterprise operating costs.

[0005] The present invention provides a method for implementing a self-service game service, including:

[0006] Receiving a self-service request sent by a target game self-service tool through a universal self-service tool interface, wherein the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal;

[0007] Parsing the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters;

[0008] Obtain service response data corresponding to the target user in the target game according to the request parameters;

[0009] Converting the service response data into target service response data that conforms to the interface specification file;

[0010] The target service response data is sent to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data.

[0011] Accordingly, an embodiment of the present application provides a device for implementing a game self-service, including:

[0012] a receiving unit, configured to receive a self-service request sent by a target game self-service tool through a universal self-service tool interface, wherein the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal;

[0013] a parsing unit, configured to parse the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters;

[0014] An acquiring unit, configured to acquire service response data corresponding to a target user in a target game according to the request parameters;

[0015] A conversion unit, configured to convert the service response data into target service response data that complies with an interface specification file;

[0016] The sending unit is configured to send the target service response data to the target game self-service tool through the universal self-service tool interface, so as to trigger the target game self-service tool to display the target service response data.

[0017] Optionally, in some embodiments of the present application, the acquiring unit may include a first determining subunit and a first acquiring subunit, as follows:

[0018] The first determining subunit is configured to determine parameter description information corresponding to the request parameter;

[0019] The first acquisition subunit is configured to acquire service response data corresponding to a target user in a target game based on the parameter description information.

[0020] Optionally, in some embodiments of the present application, the acquisition unit may further include a second acquisition subunit as follows:

[0021] The second acquisition subunit is configured to acquire empty data display information corresponding to a target user in a target game when the service response data corresponding to the request parameter is empty, and use the empty data display information as the service response data corresponding to the request parameter.

[0022] Optionally, in some embodiments of the present application, the game self-service implementation device may further include a configuration unit, which is used to configure the service response data before the step of "converting the service response data into target service response data that complies with the interface specification file".

[0023] Optionally, in some embodiments, the configuration unit may include a second determining subunit and a configuration subunit, as follows:

[0024] The second determining subunit is configured to determine a configuration file of the service response data;

[0025] The configuration subunit is used to display and configure the service response data according to the configuration file.

[0026] Optionally, in some embodiments of the present application, the configuration file includes a display configuration sub-file and a hidden configuration sub-file, and the service response data includes at least one parameter field; the configuration sub-unit can be specifically used to identify the field type of the parameter field; when the parameter field belongs to the display field type, the parameter field is displayed configured based on the display configuration sub-file; when the parameter field belongs to the hidden field type, the parameter field is hidden configured based on the hidden configuration sub-file.

[0027] Optionally, in some embodiments of the present application, the game self-service implementation device may further include a translation unit; the translation unit is used to translate the parameter field after the step of "displaying and configuring the service response data according to the configuration file".

[0028] Optionally, in some embodiments, the service response data includes at least one parameter field; the translation unit may include a third determination subunit and a translation subunit, as follows:

[0029] The third determining subunit is configured to determine a target parameter field that needs to be translated from the parameter field;

[0030] The translation subunit is used to translate the target parameter field.

[0031] Optionally, in some embodiments of the present application, the translation sub-unit can be specifically used to obtain a mapping relationship between a preset parameter field and a translation field; based on the mapping relationship, the target parameter field is translated to obtain a translation field corresponding to the target parameter field.

[0032] Optionally, in some embodiments of the present application, the translation unit may further include a replacement subunit, as follows:

[0033] The replacement subunit is used to replace the translation field corresponding to the target parameter field with a preset unknown field when the target parameter field lacks a corresponding mapping relationship.

[0034] Optionally, in some embodiments of the present application, the game self-service implementation device may further include a detection unit as follows:

[0035] The detection unit is used to detect the interface status of the universal self-service tool interface to determine whether the universal self-service tool interface is in an abnormal state; if so, obtain invalid page information and display an invalid page based on the invalid page information through the target game self-service tool; if not, continue to execute the step of receiving the self-service request sent by the target game self-service tool through the universal self-service tool interface.

[0036] An electronic device provided in an embodiment of the present application includes a processor and a memory, wherein the memory stores a plurality of instructions, and the processor loads the instructions to execute the steps in the game self-service implementation method provided in the embodiment of the present application.

[0037] In addition, an embodiment of the present application further provides a storage medium on which a computer program is stored, wherein when the computer program is executed by a processor, the steps in the game self-service implementation method provided in the embodiment of the present application are implemented.

[0038] The embodiment of the present application provides a method and device for implementing game self-service, which can receive a self-service request sent by a target game self-service tool through a universal self-service tool interface, wherein the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal; parse the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters; obtain service response data corresponding to the target user in the target game according to the request parameters; convert the service response data into target service response data that conforms to the interface specification file; send the target service response data to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data. The present application can uniformly maintain and configure multiple game self-service tools through a universal self-service tool interface, shortening the development cycle of game self-service tools and reducing enterprise operating costs. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0040] Figure 1a This is a scenario diagram of a method for implementing a game self-service service provided by an embodiment of the present application;

[0041] Figure 1b This is a flowchart of a method for implementing a game self-service provided by an embodiment of the present application;

[0042] Figure 1c It is a process diagram of the existing game self-service implementation method;

[0043] Figure 1d This is a structural diagram of a method for implementing a game self-service provided by an embodiment of the present application;

[0044] Figure 1e This is a page diagram of a method for implementing a game self-service provided by an embodiment of the present application;

[0045] Figure 2a This is another flow chart of the method for implementing game self-service provided by an embodiment of the present application;

[0046] Figure 2b This is another page diagram of the method for implementing the game self-service provided by an embodiment of the present application;

[0047] Figure 2c This is another page diagram of the method for implementing the game self-service provided by an embodiment of the present application;

[0048] Figure 2d This is another page diagram of the method for implementing the game self-service provided by an embodiment of the present application;

[0049] Figure 2e This is another flow chart of the method for implementing game self-service provided by an embodiment of the present application;

[0050] Figure 3a This is a schematic diagram of the structure of the device for implementing the game self-service provided in an embodiment of the present application;

[0051] Figure 3b This is another structural diagram of the game self-service implementation device provided in an embodiment of the present application;

[0052] Figure 3c This is another structural diagram of the device for implementing game self-service provided by an embodiment of the present application;

[0053] Figure 3d This is another structural diagram of the game self-service implementation device provided in an embodiment of the present application;

[0054] Figure 3e This is another structural diagram of the device for implementing game self-service provided by an embodiment of the present application;

[0055] Figure 3f This is another structural diagram of the game self-service implementation device provided in an embodiment of the present application;

[0056] Figure 3g This is another structural diagram of the game self-service implementation device provided in an embodiment of the present application;

[0057] Figure 4 It is a structural diagram of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0058] The following will be combined with the drawings in the embodiments of this application to clearly and completely describe the technical solutions in the embodiments of this application. Obviously, the embodiments described are only part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this 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 embodiments of the present application provide a method and apparatus for implementing a game self-service. The game self-service apparatus can be integrated into an electronic device, such as a terminal or a server.

[0060] It is understandable that the game self-service implementation method of this embodiment can be executed on the terminal, on the server, or jointly by the terminal and the server. The above examples should not be understood as limiting the present application.

[0061] like Figure 1a As shown, a method for implementing a game self-service is performed by a terminal and a server together as an example. The game self-service implementation system provided in the embodiment of the present application includes a terminal 10 and a server 11. The terminal 10 and the server 11 are connected via a network, such as a wired or wireless network, wherein the game self-service implementation device can be integrated into the server.

[0062] The server 11 can be configured to: receive a self-service request from a target game self-service tool in the terminal 10 via a universal self-service tool interface, where the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal 10; parse the self-service request based on an interface specification file of the universal self-service tool interface to obtain request parameters; obtain service response data corresponding to a target user in the target game based on the request parameters; convert the service response data into target service response data that complies with the interface specification file; and send the target service response data to the target game self-service tool via the universal self-service tool interface to trigger the target game self-service tool in the terminal 10 to display the target service response data. The server 11 can be a single server, or a server cluster or cloud server consisting of multiple servers.

[0063] The target game self-service tool in terminal 10 can send a self-service request to server 11 via a universal self-service tool interface, so that server 11 obtains corresponding target service response data based on the self-service request and sends the target service response data to the target game self-service tool in terminal 10; the target game self-service tool in terminal 10 receives the target service response data and displays it. Terminal 10 can include a mobile phone, smart TV, tablet computer, laptop computer, or personal computer (PC). A client can also be provided on terminal 10, which can be an application client or a browser client.

[0064] It should be noted that the order of description of the following embodiments is not intended to limit the preferred order of the embodiments.

[0065] The embodiments of the present application will be described from the perspective of a game self-service implementation device, which can be specifically integrated into an electronic device, which can be a server, a terminal, or other device.

[0066] The game self-service implementation method of the embodiment of the present application can be applied to the development of various types of game self-service tools and game self-service request scenarios, such as query-type game self-service tools and operation-type game self-service tools. Among them, query-type game self-service tools can help game players query game props flow, currency flow, penalty records, login records, etc.; operation-type game self-service tools can help game players solve game problems, such as self-service unblocking, self-repair of network anomalies, repair of client anomalies, and self-retrieval of props, etc. In the previous solution, each game self-service tool was developed independently, and the subsequent maintenance required separate maintenance of each game self-service tool, which had a high maintenance cost; while the present application can use a universal self-service tool interface to uniformly maintain and configure multiple game self-service tools, shortening the development cycle of game self-service tools and reducing enterprise operating costs.

[0067] like Figure 1b As shown, the specific process of the game self-service implementation method is as follows:

[0068] 101. Receive a self-service request sent by a target game self-service tool through a universal self-service tool interface, where the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal.

[0069] Game self-service tools are online services used by gamers to independently query game data and resolve gaming issues. These tools can include query tools and operation tools.

[0070] Among them, the self-service request can be to query the game prop flow, query the game login record, and self-service retrieval of game props, etc. This embodiment does not limit this.

[0071] Among them, interfaces, also known as application programming interfaces (APIs), are predefined functions that aim to provide applications and developers with the ability to access a set of routines based on certain software or hardware without having to access the source code or understand the details of the internal working mechanism.

[0072] In the specific scenario of game operation, game players will encounter various problems every day. If all problems are handed over to customer service staff to solve, it will inevitably cause a lot of manpower waste and greatly increase the operating costs of the enterprise. The emergence of game self-service tools has greatly reduced service costs. For some problems, game players can solve them themselves through self-service tools. In the current related technologies, game self-service tools are developed separately for each game, such as Figure 1c As shown, if you want to develop a self-service tool for a game, you first need to develop a data interface for the self-service tool. The data returned by the data interface (i.e., the game self-service tool interface) itself (i.e., the development output field) is usually of digital type and cannot be directly displayed to the outside world. It needs to go through a layer of translation, that is, mapping the development field into another expression, such as translating the development field into Chinese, and then displaying the translated development field on the user front end through the game self-service tool. For example, the data interface of the prop flow query tool returns the prop identification (id, Identity), but the prop id cannot be directly displayed to the user. The prop id needs to be translated into a field that the user can directly understand. Because different games and different self-service tools are developed separately, their respective translation solutions are different and need to be maintained separately in the future.

[0073] Large gaming companies operate a large number of games. If every self-service tool for each game had to be independently developed, this would result in high development costs and low efficiency for each new game launch. Similarly, since each game is developed independently, subsequent maintenance would need to be done separately. Changes to fields or translation schemes would require maintenance, which places a heavy burden on the overall maintenance workload and increases costs. Furthermore, due to the varying configurations of self-service tools across different games, the user experience could not be uniform.

[0074] In this embodiment, the game self-service tool interfaces in the terminal can be unified and integrated, and the game self-service tool interfaces can be packaged using a common format to obtain a common self-service tool interface, such as Figure 1dThe universal self-service tool interface is a common interface used by various game self-service tools in the terminal to send self-service requests and receive target service response data.

[0075] In specific scenarios, the self-service tool data for each game can be centrally managed and packaged through the server. For example, the self-service tool data for each game can be centrally managed and packaged through the data center. The data center can be considered a processing platform that collects all data and can centrally develop functional interfaces available to the front end. This can reduce system duplication and improve reusability and development efficiency.

[0076] Optionally, in one embodiment, a configuration platform can be developed to design a unified user-side tool experience. The interfaces of multiple game self-service tools can be integrated into the configuration platform for unified maintenance and configuration, enabling multi-game self-service tool configuration. The configuration platform serves as the configuration management backend for the game self-service tools, used to manage and maintain them. Specifically, it can be a game self-service tool configuration platform used by operators.

[0077] Optionally, in some embodiments, before the step of “receiving the self-service request sent by the target game self-service tool through the universal self-service tool interface”, the following steps may also be included:

[0078] Detecting the interface status of the universal self-service tool interface to determine whether the universal self-service tool interface is in an abnormal state;

[0079] If so, obtain invalid page information, and display the invalid page based on the invalid page information through the target game self-service tool;

[0080] If not, continue to execute the step of receiving the self-service request sent by the target game self-service tool through the universal self-service tool interface.

[0081] Among them, when the general self-service tool interface is in an abnormal state, the server cannot smoothly receive the self-service request, and pull the service response data corresponding to the self-service request. That is to say, the self-service is in an invalid state at this time and cannot display the target service response data to the outside world. Among them, the abnormal state may include the update and upgrade of the general self-service tool interface.

[0082] Among them, before sending a self-service request to the server, the game self-service tool in the terminal can first obtain the interface status of the general self-service tool interface, and determine whether to send a self-service request to the server based on the interface status; if the interface is abnormal, the game self-service tool can obtain invalid page information and display an invalid page, then a corresponding invalid page will appear on the tool page seen by the user on the front end, and the invalid page can specifically display the information currently under maintenance of the self-service tool.

[0083] 102. Parse the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters.

[0084] The interface specification file of the universal self-service tool interface may specify a universal format for self-service requests of various game self-service tools, and parse the self-service requests based on the universal format.

[0085] The request parameters may include a requested game ID, requested service information, and requested user ID, etc., which are not limited in this embodiment.

[0086] Optionally, in this embodiment, before the step of “parsing the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters”, the following steps may also be included:

[0087] The format of the self-service request is set to a universal format to obtain the set self-service request, and then the set self-service request is parsed based on the interface specification file of the universal self-service tool interface to obtain request parameters.

[0088] Optionally, in some embodiments, the game self-service tool may first set the format of the self-service request to a universal format, and then send the set self-service request to the server through the universal self-service tool interface.

[0089] Optionally, in a specific embodiment, since each game self-service tool interface is encapsulated using a common encapsulation format, it is necessary to unify the self-service request format of the game self-service tool interface. The common format of the self-service request can be referenced as follows:

[0090] http: / / xxx.com / param1_param2?param3=123123¶m4=20200214000000¶m5=20200217235959¶m6=0¶m7=2;

[0091] Among them, http indicates that the self-service request is transmitted based on the Hyper Text Transfer Protocol (HTTP), xxx.com indicates the domain name, "param1 (parameter 1)" can be the requested game identifier, specifically the game id, "param2 (param 2)" can be the requested service information corresponding to the self-service request, that is, the specific requested service (for example, prop flow query), "param3 = 123123 (parameter 3 = 123123)" indicates that the requesting user identifier is 123123; "param4 = 20200214000000 (parameter 4 = 20200214000000)" indicates that the query start time is 0:0:00 on February 14, 2020, and "param5 = 202 00217235959 (parameter 5 = 20200217235959)" indicates that the query end time is 23:59:59 on February 17, 2020, "param6 = 0 (parameter 6 = 0)" indicates that the data display page number starts from page 0, and "param7 = 2 (parameter 7 = 2)" indicates that the number of items displayed per page is 2; parameters 4 and 5 represent the time range for data pulling, which can be set freely. In this embodiment, the time range for pulling is 4 days. It can be understood that the background can also be configured to pull data for 7 days or 1 month; parameters 6 and 7 are the page display parameters of the target service response data corresponding to the self-service request. It should be noted that the parameter settings of this general format can be set according to actual conditions. This embodiment does not limit this. The above is just an example.

[0092] Optionally, in some embodiments, a self-service request for a game self-service tool may only include the requested game ID, requested service information, and requested user ID, i.e., parameters 1, 2, and 3 in the above example. The self-service request is then configured based on the universal format of the self-service request. This universal format configuration may include setting the query start and end times corresponding to the self-service request, as well as page display parameters for the corresponding target service response data. The configured self-service request is then sent to the server via the universal self-service tool interface, where it is parsed to obtain request parameters, including the requested game ID (game ID), requested service information, requested user ID (player ID), query start and end times, and page display parameters.

[0093] 103. Obtain service response data corresponding to the target user in the target game according to the request parameters.

[0094] The request parameters may include a requested game identifier, requested service information, and a requested user identifier. The target game can be determined based on the requested game identifier, the target user can be determined based on the requested user identifier, and the service response data corresponding to the target user in the target game can be determined based on the requested service information. The requested game identifier indicates the game corresponding to the self-service request, the requested user identifier indicates the user initiating the self-service request, and the requested service information indicates the specific requested service. The service response data contains the corresponding self-service information. For example, if the self-service request is for an item flow query, the service response data may include information about item changes for the target user in the target game during the target time period, along with the reasons for the changes.

[0095] Optionally, in some embodiments, the step of “obtaining service response data corresponding to the target user in the target game according to the request parameters” may include:

[0096] Determine parameter description information corresponding to the request parameter;

[0097] Based on the parameter description information, service response data corresponding to the target user in the target game is obtained.

[0098] In a specific embodiment, for the request parameters Param1, Param2 and Param3, first determine whether they correspond to the request game identifier, request service information and request user identifier, that is, determine their parameter description information, and then pull the corresponding data based on the request game identifier, request service information and request user identifier.

[0099] For example, you can first identify the parameter description information in the request parameters as the parameters for requesting game identification, requesting service information, and requesting user identification, such as determining that Param1 in the request parameters is the requesting game identification, Param2 is the requesting service information; Param3 is the requesting user identification; and then, based on the determination result, obtain the service response data corresponding to the target user in the target game.

[0100] A correspondence table between request parameters and parameter description information may be obtained, and based on the correspondence table, the parameter description information corresponding to the request parameters may be determined. The correspondence table may be found in Table 1 below.

[0101] Request Parameters Parameter description information Param1 Requesting a game ID Param2 Request Service Information Param3 Request user ID Param4 Query start time Param5 Query end time Param6 Data page number starting position Param7 Number of records per page

[0102] Table 1

[0103] Optionally, in some embodiments, the step of “obtaining service response data corresponding to the target user in the target game according to the request parameters” may include:

[0104] When the service response data corresponding to the request parameter is empty, empty data display information corresponding to the target user in the target game is obtained, and the empty data display information is used as the service response data corresponding to the request parameter.

[0105] Among them, when no data record can be queried through the general self-service tool interface, that is, the service response data corresponding to the request parameters cannot be obtained (the service response data is empty), the corresponding empty data display information can be configured, and the empty data display information can be sent to the target game self-service tool through the general self-service tool interface to trigger the target game self-service tool to display an empty data page based on the empty data display information. Specifically, the user can see that the corresponding empty data page will appear on the tool page on the front end, and the empty data page can display text information that there is no data.

[0106] 104. Convert the service response data into target service response data that complies with the interface specification file.

[0107] Specifically, the format of the service response data can be converted into a format that complies with the interface specification file, wherein the format may include a transmission network protocol, etc.

[0108] Optionally, in some embodiments, before the step of “converting the service response data into target service response data that complies with the interface specification file”, the following steps may also be included:

[0109] Determine a configuration file of the service response data;

[0110] The service response data is displayed and configured according to the configuration file.

[0111] The service response data includes at least one parameter field, and the parameter fields in the service response data need to be configured for external display, including which parameter fields are to be displayed externally and which invalid parameter fields are not to be displayed externally.

[0112] Taking a self-service request for a prop flow query as an example, the configuration file can be as shown in Table 2, which contains the display configuration information for each parameter field. The return parameters are the parameter fields described in the above embodiment. As can be seen from the configuration in the table, Result1 represents the result of the interface call. This is invalid information for the user and therefore does not need to be displayed. Result1 can be configured to be hidden. The other parameter fields (Result2 through Result7) contain valuable information for the user and are therefore configured to be displayed.

[0113] Return parameter Field Description Whether to display it to the user Result1 Interface success or failure no Result2 Item ID (id) yes Result3 Reasons for item changes yes Result4 Number of prop changes yes Result5 Increase or decrease yes Result6 The quantity after the change yes Result7 time yes

[0114] Table 2

[0115] Optionally, in some embodiments, the configuration file includes a display configuration subfile and a hidden configuration subfile, and the service response data includes at least one parameter field; the step of “display-configuring the service response data according to the configuration file” may include:

[0116] Identify the field type of the parameter field;

[0117] When the parameter field is a display field type, the parameter field is displayed and configured based on the display configuration subfile;

[0118] When the parameter field is a hidden field type, the parameter field is hidden configured based on the hidden configuration subfile.

[0119] If the self-service request is for an item flow query, the parameter fields may include the item ID, the reason for the item change, and the item change quantity.

[0120] Among them, the field type of the parameter field can include a display field type and a hidden field type; the parameter field corresponding to the display field type needs to be displayed to the user, and the parameter field corresponding to the hidden field type is invalid information for the user, that is, it does not need to be displayed to the user.

[0121] Optionally, in some embodiments, the service response data includes at least one parameter field; after the step of “displaying and configuring the service response data according to the configuration file”, the following steps may also be included:

[0122] Determine the target parameter field that needs to be translated from the parameter field;

[0123] The target parameter field is translated.

[0124] Among them, translation is to convert the parameter field into information that the user can understand; the target parameter field is the parameter field that needs to be translated, which can specifically be a numeric parameter field. In some embodiments, if the parameter field itself is in Chinese or English, it does not need to be translated.

[0125] Some parameter fields in the service response data need to be displayed externally, but these parameter fields may be numeric. Displaying them directly to users may cause confusion. Therefore, these parameter fields need to be translated into information that users can understand, such as translating them into corresponding Chinese or English fields.

[0126] prop id Chinese translation item1 Prop name 1 item2 Prop name 2 Item 3 Prop name 3 … …

[0127] Table 3

[0128] Alternatively, in one embodiment, using the item ID as an example, while the item ID needs to be displayed externally, it is numeric and cannot be directly displayed to the user. Instead, a Chinese translation can be configured for the item ID, translating it into a user-readable item name. For example, based on the configuration in Table 3, after the item ID is translated, the user can understand the item name.

[0129] Optionally, in some embodiments, the step of “translating the target parameter field” may include:

[0130] Get the mapping relationship between the preset parameter fields and the translation fields;

[0131] Based on the mapping relationship, the target parameter field is translated to obtain a translation field corresponding to the target parameter field.

[0132] Among them, the mapping relationship between the parameter field and the translation field can be specifically expressed as a mapping relationship table between the parameter field and the translation field. You can refer to Table 3 above. Among them, the "prop id" column is the parameter field, and the "Chinese translation" column is the corresponding translation field. Item 1 (a piece of digital type information) is translated into the corresponding Chinese information - prop name 1. Prop name 1 is the translation field of item 1.

[0133] Optionally, in some embodiments, when the target parameter field lacks a corresponding mapping relationship, the translation field corresponding to the target parameter field is replaced with a preset unknown field.

[0134] Among them, if some fields that need to be translated do not have corresponding mapping relationships, the background can perform unmatched configuration for this target parameter field, such as using a preset unknown field as its corresponding translation field to prevent the data from being exposed to the user as is, thereby reducing the user experience. The preset unknown field can be "unknown", which can be set according to actual conditions and is not limited in this embodiment. Specifically, when the prop id does not match the prop name, "unknown" can be displayed on the terminal.

[0135] Parameter fields Sorting position time 1 prop id 2 Increase or decrease 3 Number of prop changes 4 The quantity after the change 5 Reasons for item changes 6

[0136] Table 4

[0137] Optionally, in this embodiment, the parameter fields of the display field type can also be sorted and configured. After the sorting configuration is performed, the target game self-service tool will display these parameter fields in order based on the sorting configuration information. Taking the prop flow query as an example, the parameter fields can be sorted with reference to Table 4. On the corresponding user front end, the parameter fields will also be displayed in the order of 1 to 6 in Table 4, such as Figure 1eAs shown, a page is displayed based on the sorting configuration information in Table 4. The order of the parameter fields in the sorting configuration information can be set according to actual conditions, and this embodiment does not limit this.

[0138] Optionally, in some embodiments, when some parameter fields do not have corresponding field values, that is, the field values ​​are returned as null, a display message can be set for the parameter field corresponding to the null value. For example, when the field value is null, the display message can be set to "-". Specifically, if the parameter field "time" of a certain service response data lacks a corresponding field value, that is, lacks corresponding time information, the time information can be set to "-", and the field value "-" corresponding to the parameter field "time" can be displayed.

[0139] 105. Send the target service response data to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data.

[0140] The target service response data may be sent to the target game self-service tool under the target user using the requesting user ID as a parameter, wherein the requesting user ID carries the target user's information and the target user may be determined based on the requesting user ID.

[0141] The target game's self-service tool interface can be accessed through the general self-service tool interface. This interface reads the corresponding target service response data's configuration information, such as whether translation is enabled, parameter field ordering, parameter field display configuration, and parameter field Chinese translation configuration. Depending on the configuration information, front-end users will see different display methods for parameter fields.

[0142] In a specific embodiment, the self-service request service is a prop flow query, and the six parameter fields of prop id, change quantity, change reason, changed quantity, time, increase or decrease can be configured to be displayed externally, and the prop id (prop name) can be translated into Chinese. Figure 1e The following figure shows the page displaying the target service response data. Specifically, the page is a list consisting of a header and cell contents, and supports scrolling.

[0143] This embodiment enables unified maintenance and configuration of multiple game self-service tools through a universal self-service tool interface, significantly reducing development cycles and costs. Furthermore, since game self-service tools are configurable, key maintenance operations are now performed on the configuration platform. Developers no longer need to follow the release process, instead relying on configuration-based operations by operators, reducing operating costs. Furthermore, the unified configuration and standardization of game self-service tools can enhance and deepen users' understanding of the tools, providing a unified interactive and visual experience, and improving user experience.

[0144] The present application can implement the game self-service implementation method based on a variety of methods, for example, it can be implemented based on a multimedia software development kit (MSDK), an application (App), H5 (fifth generation Hypertext Markup Language (HTML)) and a mini-program.

[0145] As can be seen from the above, the electronic device of this embodiment can receive the self-service request sent by the target game self-service tool through the universal self-service tool interface, and the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of each game in the terminal; the self-service request is parsed based on the interface specification file of the universal self-service tool interface to obtain request parameters; according to the request parameters, the service response data corresponding to the target user in the target game is obtained; the service response data is converted into target service response data that conforms to the interface specification file; the target service response data is sent to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data. This application can uniformly maintain and configure multiple game self-service tools through the universal self-service tool interface, shortening the development cycle of game self-service tools and reducing enterprise operating costs.

[0146] According to the method described in the previous embodiment, the following will be further described in detail by taking the example of the specific integration of the game self-service implementation device in the server.

[0147] The embodiment of the present application provides a method for implementing a game self-service, such as Figure 2a As shown, the specific process of the game self-service implementation method can be as follows:

[0148] 201. The server detects the interface status of the universal self-service tool interface to determine whether the universal self-service tool interface is in an abnormal state; if so, execute step 202; if not, execute step 203.

[0149] 202. The server obtains invalid page information and displays an invalid page based on the invalid page information through the target game self-service tool, ending the process.

[0150] After obtaining the invalid page information, the server may send the invalid page information to the target game self-service tool to trigger the target game self-service tool to display the invalid page based on the invalid page information.

[0151] In other embodiments, the server may send the interface status detection result to the target game self-service tool. If the interface status detection result is abnormal, the target game self-service tool may obtain invalid page information and display an invalid page based on the invalid page information.

[0152] 203. The server receives the self-service request sent by the target game self-service tool through a universal self-service tool interface. The universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal.

[0153] In some embodiments, the server can send the interface status detection result to the target game self-service tool. If the interface status detection result is normal, the target game self-service tool can send a self-service request to the server through the general self-service tool interface to trigger the server to obtain corresponding service response data based on the self-service request.

[0154] 204. The server parses the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters.

[0155] The request parameters may include a requested game ID, requested service information, requested user ID, query start and end times corresponding to the self-service request, and page display parameters of the corresponding target service response data, etc. This embodiment does not impose any restrictions on this.

[0156] Among them, because each game self-service tool interface uses a common packaging format for unified packaging, it is necessary to unify the self-service request format of the game self-service tool interface. The unified format of the self-service request can be as follows, and its detailed description can be found in the previous embodiment:

[0157] http: / / xxx.com / param1_param2?param3=123123¶m4=20200214000000¶m5=20200217235959¶m6=0¶m7=2

[0158] In a specific embodiment, on the server side, operators can use the configuration platform of the game self-service tool to process self-service requests. The page of the configuration platform can be as follows: Figure 2b As shown, the "Add Self-Service Tool" control can be used to add configuration information for a new game self-service tool. Specifically, you can click the "Add Self-Service Tool" control to add the configuration information for a new game self-service tool. In the configuration platform, you can query the corresponding service response data based on the user ID, game ID, and tool name (i.e., service request information).

[0159] In this embodiment, the subsequent newly added game self-service tools also comply with the above-mentioned interface specification file; in this way, only one interface needs to be maintained to realize the development of tools for multiple games, and there is no need to maintain many interfaces independently for each game as in the traditional way.

[0160] 205. The server obtains service response data corresponding to the target user in the target game according to the request parameters.

[0161] In some embodiments, such as Figure 2c As shown, when the server receives a self-service request, the self-service request includes an interface request string, the format of which can refer to the above embodiment of http: / / xxx.com / param1_param2?param3=123123¶m4=20200214000000¶m5=20200217235959¶m6=0¶m7=2. The self-service request can be input into the "Interface Request String" input box by the operator or a preset program. Based on the operation of the "Parse Output Field" control (specifically, it can be a click operation, etc.), the self-service request is parsed to obtain the request parameters, which can be used in Figure 2c The page shown shows the request parameters: the game id is mobile game A, and the requested service information is item flow query. In addition, you can also jump to the output field information page based on the operation of the "Parse Output Field" control, such as Figure 2d As shown, the output field information page displays the service response data corresponding to the prop flow query.

[0162] In a specific embodiment, the operator or a preset program can Figure 2b Enter the request parameters, such as user ID, game ID and tool name, and then operate the "Query" control to obtain the corresponding service response data information based on the request parameters, such as Figure 2d As shown, the service response data information corresponding to the prop flow query is displayed.

[0163] 206. The server performs display configuration and translation processing on the service response data.

[0164] like Figure 2eAs shown, before the server sends the service response data to the target game self-service tool, it can also use the tool configuration platform to display and configure the parameter fields in the service response data, translate and process them, and configure the link to the game self-service tool, and then convert it into target service response data that complies with the interface specification file; and send the target service response data to the target game self-service tool through the universal self-service tool interface.

[0165] 207. The server converts the service response data into target service response data that complies with the interface specification file.

[0166] 208. The server sends the target service response data to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data.

[0167] As can be seen from the above, in this embodiment, the server can detect the interface status of the universal self-service tool interface to determine whether the universal self-service tool interface is in an abnormal state;

[0168] If so, the server obtains the invalid page information and displays the invalid page based on the invalid page information through the target game self-service tool, ending the process;

[0169] If not, the server receives the self-service request sent by the target game self-service tool through the universal self-service tool interface, where the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of each game in the terminal; parses the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters; obtains the service response data corresponding to the target user in the target game according to the request parameters; displays and configures the service response data and translates it; converts the service response data into target service response data that complies with the interface specification file; and sends the target service response data to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data.

[0170] This application can uniformly maintain and configure multiple game self-service tools through a universal self-service tool interface, shortening the development cycle of game self-service tools and reducing enterprise operating costs.

[0171] In order to better implement the above method, the embodiment of the present application also provides a game self-service implementation device, such as Figure 3a As shown, the game self-service implementation device may include a receiving unit 301, a parsing unit 302, an acquiring unit 303, a converting unit 304, and a sending unit 305, as follows:

[0172] (1) receiving unit 301;

[0173] The receiving unit 301 is configured to receive a self-service request sent by a target game self-service tool through a universal self-service tool interface. The universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal.

[0174] (2) parsing unit 302;

[0175] The parsing unit 302 is configured to parse the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters.

[0176] (3) Acquisition unit 303;

[0177] The acquisition unit 303 is configured to acquire service response data corresponding to the target user in the target game according to the request parameters.

[0178] Optionally, in some embodiments of the present application, the acquisition unit 303 may include a first determining subunit 3031 and a first acquiring subunit 3032, see Figure 3b ,as follows:

[0179] The first determining subunit 3031 is configured to determine parameter description information corresponding to the request parameter;

[0180] The first acquisition subunit 3032 is configured to acquire service response data corresponding to a target user in a target game based on the parameter description information.

[0181] Optionally, in some embodiments of the present application, the acquisition unit 303 may further include a second acquisition subunit 3033, see Figure 3c ,as follows:

[0182] The second acquisition subunit 3033 is used to obtain empty data display information corresponding to the target user in the target game when the service response data corresponding to the request parameter is empty, and use the empty data display information as the service response data corresponding to the request parameter.

[0183] (4) conversion unit 304;

[0184] The conversion unit 304 is configured to convert the service response data into target service response data that complies with the interface specification file.

[0185] (5) sending unit 305;

[0186] The sending unit 305 is configured to send the target service response data to the target game self-service tool through the universal self-service tool interface, so as to trigger the target game self-service tool to display the target service response data.

[0187] Optionally, in some embodiments of the present application, the game self-service implementation device may further include a configuration unit 306, and the configuration unit 306 is used to configure the service response data before the step of "converting the service response data into target service response data that complies with the interface specification file".

[0188] Optionally, in some embodiments, the configuration unit 306 may include a second determining subunit 3061 and a configuration subunit 3062, see Figure 3d ,as follows:

[0189] The second determining subunit 3061 is configured to determine a configuration file of the service response data;

[0190] The configuration subunit 3062 is configured to display and configure the service response data according to the configuration file.

[0191] Optionally, in some embodiments of the present application, the configuration file includes a display configuration sub-file and a hidden configuration sub-file, and the service response data includes at least one parameter field; the configuration sub-unit 3062 can be specifically used to identify the field type of the parameter field; when the parameter field belongs to the display field type, the parameter field is displayed configured based on the display configuration sub-file; when the parameter field belongs to the hidden field type, the parameter field is hidden configured based on the hidden configuration sub-file.

[0192] Optionally, in some embodiments of the present application, the game self-service implementation device may further include a translation unit 307; the translation unit 307 is used to translate the parameter field after the step of "displaying and configuring the service response data according to the configuration file".

[0193] Optionally, in some embodiments, the service response data includes at least one parameter field; the translation unit 307 may include a third determination subunit 3071 and a translation subunit 3072, see Figure 3e ,as follows:

[0194] The third determining subunit 3071 is configured to determine a target parameter field that needs to be translated from the parameter field;

[0195] The translation subunit 3072 is configured to perform translation processing on the target parameter field.

[0196] Optionally, in some embodiments of the present application, the translation subunit 3072 can be specifically used to obtain a mapping relationship between a preset parameter field and a translation field; based on the mapping relationship, the target parameter field is translated to obtain a translation field corresponding to the target parameter field.

[0197] Optionally, in some embodiments of the present application, the translation unit 307 may further include a replacement subunit 3073, see Figure 3f ,as follows:

[0198] The replacement subunit 3073 is configured to replace the translation field corresponding to the target parameter field with a preset unknown field when the target parameter field lacks a corresponding mapping relationship.

[0199] Optionally, in some embodiments of the present application, the game self-service implementation device may further include a detection unit 308, see Figure 3g ,as follows:

[0200] The detection unit 308 is used to detect the interface status of the universal self-service tool interface to determine whether the universal self-service tool interface is in an abnormal state; if so, obtain invalid page information and display an invalid page based on the invalid page information through the target game self-service tool; if not, continue to execute the step of receiving the self-service request sent by the target game self-service tool through the universal self-service tool interface.

[0201] As can be seen from the above, in this embodiment, the receiving unit 301 receives the self-service request sent by the target game self-service tool through the universal self-service tool interface, and the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal; the parsing unit 302 parses the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters; the acquisition unit 303 obtains the service response data corresponding to the target user in the target game according to the request parameters; the conversion unit 304 converts the service response data into target service response data that conforms to the interface specification file; the sending unit 305 sends the target service response data to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data. This application can uniformly maintain and configure multiple game self-service tools through the universal self-service tool interface, shortening the development cycle of game self-service tools and reducing enterprise operating costs.

[0202] The present application also provides an electronic device, such as Figure 4 , which shows a schematic diagram of the structure of an electronic device involved in an embodiment of the present application. The electronic device may be a terminal or a server, etc. Specifically:

[0203] The electronic device may include one or more processing core processors 401, one or more computer-readable storage media memories 402, a power supply 403, an input unit 404 and other components. Those skilled in the art will understand that Figure 4The electronic device structure shown in the figure does not constitute a limitation of the electronic device, and may include more or fewer components than shown in the figure, or combine certain components, or arrange components differently.

[0204] Processor 401 is the control center of the electronic device, connecting the various parts of the entire electronic device using various interfaces and lines. By running or executing software programs and / or modules stored in memory 402 and accessing data stored in memory 402, it performs various functions of the electronic device and processes data, thereby performing overall testing of the electronic device. Optionally, processor 401 may include one or more processing cores; preferably, processor 401 may integrate an application processor and a modem processor, wherein the application processor primarily processes the operating system, user interface, and application programs, and the modem processor primarily handles wireless communications. It is understood that the modem processor may not be integrated into processor 401.

[0205] The memory 402 can be used to store software programs and modules. The processor 401 executes various functional applications and data processing by running the software programs and modules stored in the memory 402. The memory 402 may mainly include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application required for at least one function (such as a sound playback function, an image playback function, etc.), etc.; the data storage area may store data created according to the use of the electronic device, etc. In addition, the memory 402 may include a high-speed random access memory, and may also include a non-volatile memory, such as at least one disk storage device, a flash memory device, or other volatile solid-state storage device. Accordingly, the memory 402 may also include a memory controller to provide the processor 401 with access to the memory 402.

[0206] The electronic device also includes a power supply 403 for supplying power to various components. Preferably, the power supply 403 can be logically connected to the processor 401 via a power management system, thereby enabling the power management system to manage charging, discharging, and power consumption. The power supply 403 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.

[0207] The electronic device may further include an input unit 404, which may be configured to receive input digital or character information and generate keyboard, mouse, joystick, optical or trackball signal inputs related to user settings and function control.

[0208] Although not shown, if the electronic device is a terminal, it may also include a display unit, etc., which will not be described in detail here. Specifically in this embodiment, the processor 401 in the electronic device will load the executable files corresponding to the processes of one or more application programs into the memory 402 according to the following instructions, and the processor 401 will run the application programs stored in the memory 402 to implement various functions as follows:

[0209] A self-service request sent by a target game self-service tool is received through a universal self-service tool interface, where the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal; the self-service request is parsed based on an interface specification file of the universal self-service tool interface to obtain request parameters; service response data corresponding to a target user in a target game is obtained based on the request parameters; the service response data is converted into target service response data that complies with the interface specification file; and the target service response data is sent to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data.

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

[0211] As can be seen from the above, this embodiment can receive the self-service request sent by the target game self-service tool through the universal self-service tool interface, and the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of each game in the terminal; the self-service request is parsed based on the interface specification file of the universal self-service tool interface to obtain request parameters; according to the request parameters, the service response data corresponding to the target user in the target game is obtained; the service response data is converted into target service response data that conforms to the interface specification file; the target service response data is sent to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data. This application can uniformly maintain and configure multiple game self-service tools through the universal self-service tool interface, shortening the development cycle of game self-service tools and reducing enterprise operating costs.

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

[0213] To this end, an embodiment of the present application provides a storage medium storing a plurality of instructions that can be loaded by a processor to execute the steps of any of the game self-service implementation methods provided in the embodiments of the present application. For example, the instructions can execute the following steps:

[0214] A self-service request sent by a target game self-service tool is received through a universal self-service tool interface, where the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal; the self-service request is parsed based on an interface specification file of the universal self-service tool interface to obtain request parameters; service response data corresponding to a target user in a target game is obtained based on the request parameters; the service response data is converted into target service response data that complies with the interface specification file; and the target service response data is sent to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data.

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

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

[0217] Since the instructions stored in the storage medium can execute the steps in any of the game self-service implementation methods provided in the embodiments of the present application, the beneficial effects that can be achieved by any of the game self-service implementation methods 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.

[0218] According to one aspect of the present application, a computer program product or computer program is provided, comprising computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the methods provided in various optional implementations of the aforementioned self-service gaming aspect.

[0219] The above is a detailed introduction to a game self-service implementation method and device 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 method for implementing game self-service, characterized in that: include: Receiving a self-service request from a target game self-service tool via a universal self-service tool interface. The universal self-service tool interface is obtained by encapsulating the self-service tool interfaces of various games in the terminal. The universal self-service tool interface is a common interface used by various game self-service tools in the terminal to send self-service requests and receive target service response data. Parsing the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters; Obtain service response data corresponding to the target user in the target game according to the request parameters; Converting the service response data into target service response data that conforms to the interface specification file; The target service response data is sent to the target game self-service tool through the universal self-service tool interface to trigger the target game self-service tool to display the target service response data.

2. The method according to claim 1, characterized in that Before converting the service response data into target service response data that conforms to the interface specification file, the method further includes: Determine a configuration file of the service response data; The service response data is displayed and configured according to the configuration file.

3. The method according to claim 2, characterized in that The configuration file includes a display configuration sub-file and a hidden configuration sub-file, and the service response data includes at least one parameter field; and display configuration of the service response data according to the configuration file includes: Identify the field type of the parameter field; When the parameter field is a display field type, the parameter field is displayed and configured based on the display configuration subfile; When the parameter field is a hidden field type, the parameter field is hidden configured based on the hidden configuration subfile.

4. The method according to claim 2, characterized in that The service response data includes at least one parameter field; after displaying and configuring the service response data according to the configuration file, the method further includes: Determine the target parameter field that needs to be translated from the parameter field; The target parameter field is translated.

5. The method according to claim 4, characterized in that The translating process of the target parameter field includes: Get the mapping relationship between the preset parameter fields and the translation fields; Based on the mapping relationship, the target parameter field is translated to obtain a translation field corresponding to the target parameter field.

6. The method according to claim 5, characterized in that The method further comprises: When the target parameter field lacks a corresponding mapping relationship, the translation field corresponding to the target parameter field is replaced with a preset unknown field.

7. The method according to claim 1, characterized in that The obtaining, according to the request parameters, service response data corresponding to the target user in the target game includes: Determine parameter description information corresponding to the request parameter; Based on the parameter description information, service response data corresponding to the target user in the target game is obtained.

8. The method according to claim 1, characterized in that The obtaining, according to the request parameters, service response data corresponding to the target user in the target game includes: When the service response data corresponding to the request parameter is empty, empty data display information corresponding to the target user in the target game is obtained, and the empty data display information is used as the service response data corresponding to the request parameter.

9. The method according to claim 1, characterized in that Before receiving the self-service request sent by the target game self-service tool through the universal self-service tool interface, the method further includes: Detecting the interface status of the universal self-service tool interface to determine whether the universal self-service tool interface is in an abnormal state; If so, obtain invalid page information, and display the invalid page based on the invalid page information through the target game self-service tool; If not, continue to execute the step of receiving the self-service request sent by the target game self-service tool through the universal self-service tool interface.

10. A device for implementing game self-service, characterized in that: include: a receiving unit, configured to receive a self-service request sent by a target game self-service tool via a universal self-service tool interface, wherein the universal self-service tool interface is obtained by uniformly encapsulating the self-service tool interfaces of various games in the terminal and is a common interface used by the self-service tools of various games in the terminal to send self-service requests and receive target service response data; a parsing unit, configured to parse the self-service request based on the interface specification file of the universal self-service tool interface to obtain request parameters; An acquiring unit, configured to acquire service response data corresponding to a target user in a target game according to the request parameters; A conversion unit, configured to convert the service response data into target service response data that complies with an interface specification file; The sending unit is configured to send the target service response data to the target game self-service tool through the universal self-service tool interface, so as to trigger the target game self-service tool to display the target service response data.

11. An electronic device, characterized in that: The system comprises a processor and a memory, wherein the memory stores a plurality of instructions, and the processor loads the instructions to execute the steps in the game self-service implementation method according to any one of claims 1 to 9.

12. A computer program product comprising computer instructions, characterized in that The computer instructions are stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, so that the computer device executes the steps in the game self-service implementation method according to any one of claims 1 to 9.

13. A storage medium, characterized in that: A computer program is stored thereon, wherein when the computer program is executed by a processor, the steps in the game self-service implementation method according to any one of claims 1 to 9 are implemented.

Images