Method, system, device and medium for developing games based on Golang

Abstract

The present application relates to a method, system, device and medium for developing a game system based on the Golang development framework, wherein the method includes: obtaining a main service link, and starting a read coroutine and a write coroutine, obtaining data sent by the main service through the read coroutine, and parsing the data according to custom rules to obtain a data packet and a packet header; then, distributing the data packet to the corresponding message queue channel, and obtaining an idle logic processing coroutine, performing logical processing on the data packet through the logic processing coroutine, obtaining processed data and storing it in redis or a database in real time; finally, returning the processed data to the write coroutine, writing the processed data to the network buffer through the write coroutine, and sending it to the main service. Through this application, the problems of low development efficiency and high development cost when developing a game system based on the Golang development framework are solved, the development efficiency is improved, and the cost is reduced.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to methods, systems, devices and media for developing a game system based on a Golang development framework. Background Art

[0002] Today's service framework development uses the C++ language, which has high requirements for developers. However, the development efficiency is relatively low, which makes it inconvenient to perform online hot updates and has the problem of single-point service. In addition, when upgrading the original service framework, due to the excessive original business logic and complex service logic, it is impossible to replace it with a new service framework at one time. For example, when using the Golang development framework for iterative replacement, there will be problems with cross-language data interaction between Golang and C++ services. This will cause the original C++ framework developers to use the golang framework for development. It will take a long time to familiarize themselves with the new framework structure, which is time-consuming and costly.

[0003] At present, there is no effective solution to the problems of low development efficiency and high development cost when developing game systems based on the Golang development framework in related technologies. Summary of the invention

[0004] The embodiments of the present application provide a method, system, device and medium for developing a game system based on a Golang development framework, so as to at least solve the problems of low development efficiency and high development cost when developing a game system based on a Golang development framework in the related art.

[0005] In a first aspect, an embodiment of the present application provides a method for developing a game system based on a Golang development framework, the method comprising:

[0006] Get the main service link, start the read coroutine and write coroutine, get the data sent by the main service through the read coroutine, and parse the data according to the custom rules to obtain the data packet and header;

[0007] Distribute the data packet to the corresponding message queue channel, obtain an idle logic processing coroutine, perform logic processing on the data packet through the logic processing coroutine, obtain the processed data and store it in redis or database in real time;

[0008] The processed data is returned to the writing coroutine, and the processing data is written into a network buffer by the writing coroutine and sent to a main service.

[0009] In some embodiments, before obtaining the primary service link, the method includes:

[0010] Start the main service, load the configuration, and start the logical coroutine pool and the listening link coroutine.

[0011] In some embodiments, before performing logical processing on the data packet by the logic processing coroutine, the method includes:

[0012] Start the corresponding logic processing coroutine according to the configuration file, and load the node data at the corresponding logic processing coroutine from the redis or database according to the hash rule;

[0013] Start the Cron timer and refresh the logic regularly through the Cron timer.

[0014] In some embodiments, parsing the data according to the custom rules to obtain the data packet and the packet header includes:

[0015] The data packet and the packet header are obtained by parsing the data through the byte storage length or the byte storage mark of whether the message is encrypted.

[0016] In a second aspect, an embodiment of the present application provides a system for developing a game system based on a Golang development framework, the system comprising:

[0017] The acquisition and parsing module is used to obtain the main service link and start the read coroutine and the write coroutine, obtain the data sent by the main service through the read coroutine, and parse the data according to the custom rules to obtain the data packet and the packet header;

[0018] A logic processing module is used to distribute the data packets to the corresponding message queue channel, obtain an idle logic processing coroutine, perform logic processing on the data packets through the logic processing coroutine, obtain the processed data and store it in redis or a database in real time;

[0019] The feedback module is used to return the processed data to the writing coroutine, write the processed data into the network buffer through the writing coroutine, and send it to the main service.

[0020] In some embodiments, the system further comprises a startup module, before acquiring the primary service link,

[0021] The startup module is used to start the main service, load the configuration, and start the logic coroutine pool and the listening link coroutine.

[0022] In some embodiments, before the data packet is logically processed by the logic processing coroutine,

[0023] The logic processing module is further used to start the corresponding logic processing coroutine according to the configuration file, and load the node data at the corresponding logic processing coroutine from the redis or database according to the hash rule;

[0024] Start the Cron timer and refresh the logic regularly through the Cron timer.

[0025] In some of the embodiments, the acquisition and parsing module is further used to parse the data to obtain the data packet and packet header by storing the length in bytes or a mark indicating whether the message is encrypted in bytes.

[0026] In a third aspect, an embodiment of the present application provides an electronic device, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, the method for developing a game system based on the Golang development framework as described in the first aspect above is implemented.

[0027] In a fourth aspect, an embodiment of the present application provides a storage medium on which a computer program is stored, which, when executed by a processor, implements the method for developing a game system based on the Golang development framework as described in the first aspect above.

[0028] Compared with the related art, the method for developing a game system based on the Golang development framework provided in the embodiment of the present application obtains the main service link, and starts the read coroutine and the write coroutine, obtains the data sent by the main service through the read coroutine, and parses the data according to custom rules to obtain the data packet and the packet header; then, distributes the data packet to the corresponding message queue channel, and obtains the idle logic processing coroutine, performs logical processing on the data packet through the logic processing coroutine, obtains the processed data and stores it in redis or database in real time; finally, returns the processed data to the write coroutine, writes the processed data to the network buffer through the write coroutine, and sends it to the main service.

[0029] This application separates the read-write coroutine from the logic coroutine, which can improve development efficiency. In addition, this application can also support user-imperceptible hot updates, and is compatible with the original services developed with the old version of vc2005 c++, effectively reducing learning costs, and improving multi-core CPU utilization, solving the problems of low development efficiency and high development costs when developing game systems based on the Golang development framework. BRIEF DESCRIPTION OF THE DRAWINGS

[0030] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0031] Figure 1 This is a schematic diagram of a workflow for developing a game system based on a Golang development framework according to an embodiment of the present application;

[0032] Figure 2It is a flow chart of a method for developing a game system based on a Golang development framework according to an embodiment of the present application;

[0033] Figure 3 It is a system structure block diagram of a game system developed based on the Golang development framework according to an embodiment of the present application;

[0034] Figure 4 It is another system structure block diagram of developing a game system based on the Golang development framework according to an embodiment of the present application;

[0035] Figure 5 It is a schematic diagram of the internal structure of an electronic device according to an embodiment of the present application. DETAILED DESCRIPTION

[0036] In order to make the purpose, technical solutions and advantages of the present application clearer, the present application is described and illustrated below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not intended to limit the present application. Based on the embodiments provided in the present application, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present application. In addition, it can also be understood that although the efforts made in this development process may be complex and lengthy, for ordinary technicians in the field related to the contents disclosed in the present application, some changes such as design, manufacturing or production based on the technical contents disclosed in the present application are only conventional technical means, and should not be understood as insufficient contents disclosed in the present application.

[0037] Reference to "embodiments" in this application means that a particular feature, structure, or characteristic described in conjunction with the embodiments may be included in at least one embodiment of the present application. The appearance of the phrase in various locations in the specification does not necessarily refer to the same embodiment, nor is it an independent or alternative embodiment that is mutually exclusive with other embodiments. It is explicitly and implicitly understood by those of ordinary skill in the art that the embodiments described in this application may be combined with other embodiments without conflict.

[0038] Unless otherwise defined, the technical terms or scientific terms involved in this application should be understood by people with ordinary skills in the technical field to which this application belongs. The words "one", "a", "a", "the" and the like involved in this application do not indicate a quantity limitation, and may indicate the singular or plural. The terms "include", "comprise", "have" and any of their variations involved in this application are intended to cover non-exclusive inclusions; for example, a process, method, system, product or device that includes a series of steps or modules (units) is not limited to the listed steps or units, but may also include steps or units that are not listed, or may also include other steps or units inherent to these processes, methods, products or devices. The words "connect", "connected", "coupled" and the like involved in this application are not limited to physical or mechanical connections, but may include electrical connections, whether direct or indirect. The "multiple" involved in this application means greater than or equal to two. "And / or" describes the association relationship of associated objects, indicating that there can be three relationships. For example, "A and / or B" can mean: A exists alone, A and B exist at the same time, and B exists alone. The terms "first", "second", "third" and the like involved in the present application are merely used to distinguish similar objects and do not represent a specific ordering of the objects.

[0039] This embodiment provides a method for developing a game system based on the Golang development framework. Figure 1 : is a schematic diagram of a workflow for developing a game system based on a Golang development framework according to an embodiment of the present application, such as Figure 1 As shown, Figure 2 is a flow chart of a method for developing a game system based on a Golang development framework according to an embodiment of the present application, such as Figure 2 As shown, the process includes the following steps:

[0040] Step S201, obtain the main service link, and start the read coroutine and the write coroutine, obtain the data sent by the main service through the read coroutine, and parse the data according to the custom rules to obtain the data packet and the packet header; it should be noted that the main service can be a client or a server;

[0041] Preferably, before obtaining the main service link, it is necessary to start the main service, load the configuration, and start the logical coroutine pool and the listening link coroutine. Specifically, the configuration content includes: operating mode (debug / release), service name, service ID, log path, listening link port / address, and active link port / address, in addition, it also includes the number of network buffers, coroutine pool size, started logical modules and database address, etc.;

[0042] Furthermore, after obtaining the main service link, the link is encapsulated, and a read coroutine and a write coroutine are started for the link. The data sent by the main service is obtained through the read coroutine, and the data is parsed according to the custom rules to obtain the data packet and the header. Preferably, in this embodiment, the data is parsed by storing the length in bytes or the mark of whether the message is encrypted in bytes, etc., to obtain the data packet and the header, so as to be compatible with the existing services in the Golang development framework;

[0043] It should be noted that in this embodiment, the reading coroutine is responsible for reading the message sent by the main service from the network buffer and passing it to the logic processing coroutine pool through the message queue channel (Channel); the writing coroutine is responsible for writing the network data generated by this service into the network buffer and sending it to other services, such as Figure 1 In the ws world server;

[0044] Step S202, distribute the data packet to the corresponding message queue channel, obtain the idle logic processing coroutine, perform logic processing on the data packet through the logic processing coroutine, obtain the processed data and store it in redis or database in real time;

[0045] Specifically, in this embodiment, Figure 1 As shown, the reading coroutine distributes the data packet to the corresponding message queue channel, obtains the idle logic processing coroutine, and performs logic processing on the data packet through the logic processing coroutine.

[0046] Preferably, before performing logical processing on a data packet through a logical processing coroutine, this embodiment starts a corresponding logical processing coroutine according to a configuration file, and loads node data at the corresponding logical processing coroutine from redis or a database according to a hash rule; then, starts a Cron timer, refreshes the logic periodically through the Cron timer, and executes the logic periodically according to the set time.

[0047] Furthermore, the logic processing coroutine executes the corresponding business logic to obtain the processed data, and stores the processed data in redis or a database.

[0048] It should be noted that the above-mentioned stateful mode is used for logical processing, that is, the user's status data is saved in the service. When the service is started or the user uses the function provided by this service, the user's relevant data will be loaded from the database and saved in the memory of this service, wherein the data only needs to be loaded from the database once. After the user generates other data operations, the original memory data will be modified and stored in the database in real time. Therefore, the advantages of the stateful mode are: the data is stored in the memory and the response speed is fast. In addition, the present application can also use the stateless mode for logical processing, that is, the user's status data is not retained in the service's memory, and the data is stored in memory storage services such as redis / memorycache. When the user generates a request, the required data is pulled from redis, that is, the required data needs to be obtained from the database each time. Therefore, the advantages of the stateless mode are: convenient horizontal expansion and support for high availability. Therefore, this embodiment can select a stateful mode or a stateless mode according to the business by comprehensively considering the performance and high availability requirements;

[0049] Step S203, returning the processed data to the writing coroutine, writing the processed data into the network buffer through the writing coroutine, and sending it to the main service.

[0050] Preferably, Figure 1 As shown, this embodiment returns the processed data to the write coroutine, which writes the processed data into the network buffer, sends it to the ws world server, and then sends it to the main service to implement corresponding data instruction indications, such as hot update indications of the game system.

[0051] Through the above steps S201 to S203, this embodiment separates the read-write coroutine from the logic coroutine, which can improve development efficiency; in addition, the embodiment of the present application supports both stateful and stateless modes, which can improve the service level expansion capability and support user-imperceptible hot updates; at the same time, the embodiment of the present application can be compatible with the original services developed with the old version of vc2005 c++ through custom parsing rules, effectively reducing learning costs, improving multi-core CPU utilization, and solving the problems of low development efficiency and high development costs when developing game systems based on the Golang development framework.

[0052] In some of the embodiments, the development framework supports not only the client mode but also the server mode. When the server mode is used, the client service actively connects to the server service to form a cluster; when the client mode is used, the client service connects to other services to form a cluster.

[0053] It should be noted that the steps shown in the above process or the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0054] The present embodiment also provides a system for developing a game system based on the Golang development framework, which is used to implement the above-mentioned embodiments and preferred implementation modes, and will not be repeated hereafter. As used below, the terms "module", "unit", "subunit", etc. can implement a combination of software and / or hardware of a predetermined function. Although the devices described in the following embodiments are preferably implemented in software, the implementation of hardware, or a combination of software and hardware, is also possible and contemplated.

[0055] Figure 3 : is a system structure diagram of a game system developed based on a Golang development framework according to an embodiment of the present application, such as Figure 3 As shown, the system includes an acquisition and analysis module 31, a logic processing module 32 and a feedback module 33:

[0056] The acquisition and parsing module 31 is used to obtain the main service link and start the read coroutine and the write coroutine. The data sent by the main service is obtained through the read coroutine, and the data is parsed according to the custom rules to obtain the data packet and the packet header; the logic processing module 32 is used to distribute the data packet to the corresponding message queue channel, and obtain the idle logic processing coroutine, perform logic processing on the data packet through the logic processing coroutine, obtain the processed data and store it in redis or database in real time; the feedback module 33 is used to return the processed data to the write coroutine, write the processed data to the network buffer through the write coroutine, and send it to the main service.

[0057] Through the above system, this embodiment separates the read-write coroutine from the logic coroutine, which can improve development efficiency; in addition, the embodiment of the present application supports both stateful and stateless modes, which can improve the service level expansion capability and support user-imperceptible hot updates; at the same time, the embodiment of the present application can be compatible with the original services developed with the old version of vc2005 c++ through custom parsing rules, effectively reducing learning costs, improving multi-core CPU utilization, and solving the problems of low development efficiency and high development costs when developing game systems based on the Golang development framework.

[0058] In some embodiments, the system further comprises a startup module. Figure 4 is another system structure block diagram of developing a game system based on the Golang development framework according to an embodiment of the present application, such as Figure 4As shown, the system includes a startup module 41, an acquisition and parsing module 31, a logic processing module 32 and a feedback module 33. The startup module 41 is used to start the main service, load the configuration, and start the logic coroutine pool and the listening link coroutine. Specifically, the configuration content includes: operating mode (debug / release), service name, service ID, log path, port / address of the listening link, and port / address of the active link. In addition, it also includes the number of network buffers, the size of the coroutine pool, the started logic module and the database address.

[0059] It should be noted that the specific examples in this embodiment can refer to the examples described in the above embodiments and optional implementation modes, and this embodiment will not be described in detail here.

[0060] In addition, it should be noted that the above modules can be functional modules or program modules, and can be implemented by software or hardware. For modules implemented by hardware, the above modules can be located in the same processor; or the above modules can be located in different processors in any combination.

[0061] This embodiment further provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to execute the steps in any one of the above method embodiments.

[0062] Optionally, the electronic device may further include a transmission device and an input / output device, wherein the transmission device is connected to the processor, and the input / output device is connected to the processor.

[0063] In addition, in combination with the method for developing a game system based on the Golang development framework in the above embodiment, the embodiment of the present application can provide a storage medium for implementation. The storage medium stores a computer program; when the computer program is executed by the processor, any one of the methods for developing a game system based on the Golang development framework in the above embodiment is implemented.

[0064] In one embodiment, a computer device is provided, which may be a terminal. The computer device includes a processor, a memory, a network interface, a display screen, and an input device connected via a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external terminal via a network connection. When the computer program is executed by the processor, a method for developing a game system based on a Golang development framework is implemented. The display screen of the computer device may be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer device may be a touch layer covered on the display screen, or a key, trackball or touchpad provided on the housing of the computer device, or an external keyboard, touchpad or mouse, etc.

[0065] In one embodiment, Figure 5 is a schematic diagram of the internal structure of an electronic device according to an embodiment of the present application, such as Figure 5 As shown, an electronic device is provided, which may be a server, and its internal structure diagram may be as shown in Figure 5 As shown. The electronic device includes a processor, a network interface, an internal memory and a non-volatile memory connected through an internal bus, wherein the non-volatile memory stores an operating system, a computer program and a database. The processor is used to provide computing and control capabilities, the network interface is used to communicate with an external terminal through a network connection, the internal memory is used to provide an environment for the operation of the operating system and the computer program, and when the computer program is executed by the processor, a method for developing a game system based on the Golang development framework is implemented, and the database is used to store data.

[0066] Those skilled in the art will understand that Figure 5 The structure shown in the figure is merely a block diagram of a partial structure related to the scheme of the present application, and does not constitute a limitation on the electronic device to which the scheme of the present application is applied. The specific electronic device may include more or fewer components than shown in the figure, or combine certain components, or have a different arrangement of components.

[0067] Those of ordinary skill in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the embodiments provided in this application may include non-volatile and / or volatile memory. Non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory may include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in many forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0068] Those skilled in the art should understand that the technical features of the above-described embodiments may be arbitrarily combined. To make the description concise, not all possible combinations of the technical features in the above-described embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0069] The above-mentioned embodiments only express several implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of the invention patent. It should be pointed out that, for a person of ordinary skill in the art, several variations and improvements can be made without departing from the concept of the present application, and these all belong to the protection scope of the present application. Therefore, the protection scope of the patent of the present application shall be subject to the attached claims.

Claims

1. A method for developing a game system based on a Golang development framework, characterized in that: The method comprises: Start the main service, load the configuration, and start the logic coroutine pool and the listening link coroutine, where the configuration content includes the number of network buffers, the size of the coroutine pool, the started logic module and the database address. The main service is the client or the server; Obtain the main service link, encapsulate the main service link, and start a read coroutine and a write coroutine for the main service link. Obtain the data sent by the main service through the read coroutine, and parse the data to obtain a data packet and a packet header through a byte storage length or a byte storage message encryption mark. The read coroutine is responsible for reading the message sent by the main service from the network buffer and passing it to the logic processing coroutine pool through the message queue channel; Distribute the data packet to the corresponding message queue channel, obtain an idle logic processing coroutine, perform logic processing on the data packet through the logic processing coroutine, obtain the processed data and store it in redis or database in real time, the logic processing includes stateful mode and stateless mode, the stateful mode saves the user's state data, and the stateless mode does not save the user's state data; The processed data is returned to the writing coroutine, and the processing data is written into a network buffer by the writing coroutine and sent to the main service.

2. The method according to claim 1, characterized in that Before performing logical processing on the data packet through the logical processing coroutine, the method includes: Start the corresponding logic processing coroutine according to the configuration file, and load the node data at the corresponding logic processing coroutine from the redis or database according to the hash rule; Start the Cron timer and refresh the logic regularly through the Cron timer.

3. A system for developing a game system based on the Golang development framework, characterized in that: The system comprises: Obtain a parsing module, which is used to start the main service, load the configuration, and start the logic coroutine pool and the listening link coroutine, wherein the configuration content includes the number of network buffers, the size of the coroutine pool, the started logic module and the database address, and the main service is the client or the server; A storage module is used to obtain a main service link, encapsulate the main service link, and start a read coroutine and a write coroutine for the main service link, obtain data sent by the main service through the read coroutine, and parse the data to obtain a data packet and a packet header through a byte storage length or a byte storage message encryption mark, wherein the read coroutine is responsible for reading the message sent by the main service from the network buffer and passing it to the logic processing coroutine pool through the message queue channel; A logic processing module is used to distribute the data packets to the corresponding message queue channel, obtain an idle logic processing coroutine, perform logic processing on the data packets through the logic processing coroutine, obtain the processed data and store it in redis or a database in real time. The logic processing includes a stateful mode and a stateless mode. The stateful mode saves the user's state data, and the stateless mode does not save the user's state data; A feedback module is used to return the processed data to the writing coroutine, write the processed data into a network buffer through the writing coroutine, and send it to the main service.

4. The system according to claim 3, characterized in that Before the data packet is logically processed by the logic processing coroutine, The logic processing module is also used to start the corresponding logic processing coroutine according to the configuration file, and load the node data at the corresponding logic processing coroutine from the redis or database according to the hash rule; Start the Cron timer and refresh the logic regularly through the Cron timer.

5. An electronic device comprising a memory and a processor, characterized in that: A computer program is stored in the memory, and the processor is configured to run the computer program to execute the method for developing a game system based on a Golang development framework according to any one of claims 1 to 2.

6. A storage medium, characterized in that: The storage medium stores a computer program, wherein the computer program is configured to execute the method for developing a game system based on a Golang development framework according to any one of claims 1 to 2 when running.

Images