System for providing a chess game using network-based simultaneous piece movement

Abstract

The present invention relates to a network-based simultaneous piece movement chess game provision system that allows both players to move their pieces simultaneously and determine the winner according to predetermined rules, rather than the traditional turn-based chess method in which both players take turns moving their pieces.

Description

Technology Field

[0001] The present invention relates to a method for providing a network-based simultaneous piece movement chess game, and more specifically, to a chess game system based on a network environment. More specifically, it relates to a network-based simultaneous piece movement chess game system in which, rather than the traditional turn-based chess method in which both players take turns moving pieces, both players move pieces simultaneously and the winner is determined according to predetermined rules. Background Technology

[0003] Generally, chess is a strategy game played by two players who take turns moving chess pieces on an 8x8 grid board with the ultimate goal of capturing the opponent's king. It has been popularized worldwide for a long time and is implemented in various forms, such as online chess via the internet, mobile chess applications, and AI battle chess.

[0004] Conventional online chess systems fundamentally maintain a sequential turn-based structure where the opponent can only make a move after one player has made a move and the result has been reflected on the server. While this structure is essential for adhering to the fundamental rules of chess, in a network environment, problems arise such as reduced real-time responsiveness and decreased immersion due to latency and network delays.

[0005] In particular, instances where the game is interrupted or the flow is broken due to the opponent's prolonged non-response occur frequently, significantly degrading the user experience. Furthermore, in turn-based structures, since one decides their move while the opponent's moves are fully revealed, strategic prediction becomes monotonous and it is difficult for new tactical variables to emerge. Therefore, despite their high level of sophistication, existing chess systems have limitations in that they struggle to implement spontaneous variability and real-time combat tension.

[0006] Furthermore, existing online chess systems are merely forms of a physical chessboard transferred to a virtual space, and they fail to incorporate new technical elements such as network synchronization methods or collision detection logic. Consequently, since real-time bidirectional input processing technology is not applied to strategy games like chess, there are structural constraints that make it difficult to develop them into responsive games on a network.

[0007] Meanwhile, the aforementioned background technology is technical information that the inventor possessed for the derivation of the present invention or acquired during the process of deriving the present invention, and it cannot necessarily be considered publicly known technology disclosed to the general public prior to the filing of the present invention. The problem to be solved

[0009] The present invention has been devised to solve the aforementioned problems, and more specifically, provides a network-based simultaneous piece movement chess game provision system that allows both players to move their pieces simultaneously and determine the winner according to predetermined rules, rather than the traditional turn-based chess method in which both players take turns moving their pieces.

[0010] The technical problems of the present invention are not limited to those mentioned above, and other unmentioned technical problems will be clearly understood by those skilled in the art from the description below. means of solving the problem

[0012] A network-based simultaneous piece movement method chess game providing system according to one embodiment of the present invention provides a chess game in which two players matched through an online match move their pieces simultaneously and the winner is determined according to predetermined rules.

[0013] The above-mentioned network-based simultaneous piece movement method chess game providing system is,

[0014] A game preparation unit that displays a chess game by placing each player's pieces on a chessboard in which multiple areas are arranged in two dimensions on each of the terminals of both players matched through an online match;

[0015] A simultaneous movement command receiving unit that receives input for the movement of at least one piece from each of both players within the same time limit; and

[0016] It includes an output unit that implements the results of the piece movements of both players received from the simultaneous movement command receiving unit on the chessboard to update the state of the pieces, and simultaneously displays the updated results on the terminal screens of both players.

[0017] The above output unit is,

[0018] Calculate the movement path of each piece according to the movement commands received from the terminals of both players, using coordinate units assigned to the area columns of the chessboard,

[0019] In the process of implementing the results of the two players' piece movements on the chessboard, if the first piece selected by the first player and the second piece selected by the second player move to the same coordinates, it is determined that the first piece and the second piece have collided, and the coordinates of the area where the different pieces collided are set as the collision occurrence coordinates.

[0020] The above output unit is,

[0021] For a collision between the first piece and the second piece that have moved to the above collision occurrence coordinates, the winner and loser are determined based on pre-set class rules,

[0022] When pieces of different classes collide, the higher-class piece is treated as having moved to the collision coordinates, and the lower-class piece is removed.

[0023] If pieces of the same rank collide, both pieces are removed from the chessboard, and

[0024] If at least one pawn exists among the pieces that moved to the above collision coordinates, both pieces are removed from the chessboard, and

[0025] The above rank rules are characterized by having priority in the order of King, Queen, Bishop, Knight, Rook, and Pawn.

[0026] The above output unit is,

[0027] By setting a rank and initial combat power for each piece, if a specific piece moves consecutively more than a certain number of times during the chess game, its combat power is decreased, and if it does not move more than a certain number of times, its combat power is increased.

[0028] For a collision between a first piece and a second piece that has moved to the above collision occurrence coordinates, the winner and loser between the pieces are determined based on the combat power assigned to each piece,

[0029] It is characterized by the fact that the higher the rank of the piece, the lower the probability of its combat power decreasing and the higher the probability of its combat power increasing, while the lower the rank of the piece, the higher the probability of its combat power decreasing and the lower the probability of its combat power increasing.

[0030] The above output unit is,

[0031] The King piece is set to an initial combat power of 100, a combat power decrease probability of 10%, and a combat power increase probability of 70%, and

[0032] The Queen piece is set to an initial combat power of 80, a 20% chance of decreasing combat power, and a 60% chance of increasing combat power, and

[0033] The Bishop piece is set to an initial combat strength of 60, a 30% chance of decreasing combat strength, and a 50% chance of increasing combat strength, and

[0034] The Knight unit is set to an initial combat strength of 50, a 20% chance of decreasing combat strength, and a 60% chance of increasing combat strength, and

[0035] The Rook unit is set to an initial combat strength of 30, a 50% chance of decreasing combat strength, and a 40% chance of increasing combat strength, and

[0036] The Pawn is set to an initial combat strength of 15, a 40% chance of decreasing combat strength, and a 60% chance of increasing combat strength, and

[0037] It is characterized by reducing the combat power by 10% when the number of consecutive moves of each piece is 3 or more, and increasing the combat power by 10% when the number of consecutive stops is 3 or more. Effects of the invention

[0039] According to one aspect of the present invention described above, a network-based simultaneous piece movement chess game provision system is implemented in which two players move their respective pieces within the same time limit and a server simultaneously determines the results. Accordingly, a real-time interactive game environment, which was impossible in conventional turn-based chess games, is realized, and synchronization between the server and the terminal and the automation of collision detection are achieved, thereby significantly improving the responsiveness and immersion of the entire game. Brief explanation of the drawing

[0041] FIG. 1 is a diagram showing the schematic configuration of a network-based simultaneous piece movement method chess game providing system according to one embodiment of the present invention. Specific details for implementing the invention

[0042] The following detailed description of the invention refers to the accompanying drawings, which illustrate specific embodiments in which the invention may be practiced. These embodiments are described in sufficient detail to enable those skilled in the art to practice the invention. It should be understood that various embodiments of the invention are different but need not be mutually exclusive. For example, specific shapes, structures, and characteristics described herein may be implemented in other embodiments without departing from the spirit and scope of the invention in relation to one embodiment. It should also be understood that the location or arrangement of individual components within each disclosed embodiment may be changed without departing from the spirit and scope of the invention. Accordingly, the following detailed description is not intended to be limiting, and the scope of the invention is limited only by the appended claims, including all equivalents to those claimed therein, provided appropriately described. Similar reference numerals in the drawings refer to the same or similar functions across various aspects.

[0043] In this specification, terms such as “comprising” or “having” are intended to indicate the existence of the features, numbers, steps, actions, components, parts, or combinations thereof described in the specification, and should be understood as not precluding the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof. Where one component is described as being “connected” or “combined” with another component, it may be directly connected to or connected to that other component, but there may be other in between.

[0044] It should be understood that components may exist. On the other hand, when it is stated that one component is "directly connected" or "directly coupled" to another component, it should be understood that no other component exists in between.

[0045] Meanwhile, a "module" or "part" for a component as used in this specification performs at least one function or operation. Furthermore, a "module" or "part" may perform a function or operation by hardware, software, or a combination of hardware and software. Additionally, a plurality of "modules" or a plurality of "parts," excluding a "module" or "part" that must be performed on specific hardware or on at least one processor, may be integrated into at least one module. A singular expression includes a plural expression unless the context clearly indicates otherwise.

[0046] In addition, power, power transmission, and control therefor for the following assembly configurations and embodiments, including "by control," follow conventional technology including terminals, applications, hardware control modules, etc., so they are omitted to avoid redundancy.

[0047] In addition, the operation embodiments and configurations described in a general manner without being explained in detail below follow the prior art and are omitted in order to focus on describing the purpose of the present invention and the resulting effects.

[0048] Furthermore, in describing the present invention, if it is determined that a detailed description of related known functions or configurations may unnecessarily obscure the essence of the invention, such detailed description is abbreviated or omitted.

[0049] Hereinafter, preferred embodiments of the present invention will be described in more detail with reference to the drawings.

[0050] FIG. 1 is a diagram showing the schematic configuration of a network-based simultaneous piece movement method chess game providing system according to one embodiment of the present invention.

[0051] The network-based simultaneous piece movement method chess game providing system according to the present invention aims to provide a chess game in which two players matched through an online match move their pieces simultaneously and the winner is determined according to predetermined rules, rather than the traditional turn-based chess method in which both players take turns moving pieces.

[0052] To this end, the network-based simultaneous piece movement method chess game providing system according to the present invention can be implemented in a chess game management server (hereinafter referred to as the server).

[0053] The server may be a self-contained server for the service according to the present invention, a cloud server, or a peer-to-peer (P2P) set of distributed nodes.

[0054] The server can perform one or more of the computation, storage, reference, input / output, and control functions of a general computer, and may include an artificial neural network described below based on input data.

[0055] The server may include a processor and memory. The processor may perform a smart interior service according to the present invention and may include devices capable of performing such service. The processor may execute a program or control the server. Program code executed by the processor may be stored in memory. The memory may store relevant information for performing the service according to the present invention or a program for implementing a method. The memory may be volatile memory or non-volatile memory.

[0056] The server can use a network to send data to an external device or receive data from an external device.

[0057] The server can train artificial neural networks and can also utilize artificial neural networks once training is complete. The processor can train or execute artificial neural networks stored in memory, and memory can store artificial neural networks once training is complete. The electronic device that trains the artificial neural network and the electronic device that uses it may be the same, but they may also be separate.

[0058] The artificial intelligence-related functions according to the present disclosure are operated through a processor and memory. The processor may be composed of one or more processors. In this case, the one or more processors may be general-purpose processors such as CPUs, APs, and DSPs (Digital Signal Processors), graphics-dedicated processors such as GPUs and VPUs (Vision Processing Units), or artificial intelligence-dedicated processors such as NPUs. The one or more processors control the processing of input data according to predefined operation rules or artificial intelligence models stored in memory. Alternatively, if the one or more processors are artificial intelligence-dedicated processors, the artificial intelligence-dedicated processors may be designed with a hardware structure specialized for processing a specific artificial intelligence model.

[0059] The predefined rules of operation or artificial intelligence models are characterized by being created through learning. Here, being created through learning means that a basic artificial intelligence model is trained using a number of training data by a learning algorithm, thereby creating predefined rules of operation or artificial intelligence models configured to perform desired characteristics (or objectives). Such learning may be performed on the device itself where the artificial intelligence according to the present disclosure is executed, or it may be performed through a separate server and / or system. Examples of learning algorithms include supervised learning, unsupervised learning, semi-supervised learning, or reinforcement learning, but are not limited to the examples described above.

[0060] An artificial intelligence model can be composed of multiple neural network layers. Each of the multiple neural network layers has multiple nodes and weight values, and

[0061] A neural network through operations between the computation results of the previous layer and multiple weights

[0062] It performs operations. Multiple weights possessed by multiple neural network layers can be optimized based on the learning results of the artificial intelligence model. For example, multiple weights can be updated so that the loss value or cost value obtained from the artificial intelligence model during the learning process is reduced or minimized. Additionally, to minimize the loss value or cost value, multiple weights can be updated in a direction that minimizes the gradient associated with the loss value or cost value. Artificial neural networks may include deep neural networks (DNNs), such as Convolutional Neural Networks (CNNs), Deep Neural Networks (DNNs), Recurrent Neural Networks (RNNs), Restricted Boltzmann Machines (RBMs), Deep Belief Networks (DBNs), Bidirectional Recurrent Deep Neural Networks (BRDNNs), or Deep Q-Networks, but are not limited to the examples mentioned above.

[0063] A network is a network that serves as a transmission path for web pages; it may be a closed network such as a LAN (Local Area Network) or WAN (Wide Area Network), but it is desirable for it to be an open network such as the Internet. The Internet refers to a global open computer network structure that provides the TCP / IP protocol and various services existing at its upper layers, namely HTTP (HyperText Transfer Protocol), Telnet, FTP (File Transfer Protocol), DNS (Domain Name System), SMTP (Simple Mail Transfer Protocol), SNMP (Simple Network Management Protocol), NFS (Network File Service), and NIS (Network Information Service).

[0064] Terminals can be implemented in various forms. For example, the terminals described in this specification may include mobile terminals such as smartphones, tablet PCs, PDAs, portable multimedia players, and MP3 players, as well as fixed terminals such as smart TVs and desktop computers.

[0065] Specifically, the network-based simultaneous piece movement method chess game providing system according to the present invention includes a game preparation unit, a simultaneous movement command receiving unit, and an output unit.

[0066] The Game Preparation Unit configures the initial environment for two players matched via a network to play a chess game simultaneously. By generating the data structure for the chessboard, registering the initial attributes and combat power of each piece, and performing data synchronization and verification procedures between the server and each player's terminal, the Game Preparation Unit provides a foundation for the stable operation of simultaneous movement command processing and collision detection in subsequent stages.

[0067] To this end, the game preparation unit creates a chessboard structure in the form of a two-dimensional grid on the server memory.

[0068] As shown in FIG. 2, the chessboard is composed of 64 independent coordinates defined with the horizontal axis as the alphabet A to H and the vertical axis as the number 1 to 8, each coordinate is assigned a Cell_ID, and includes information such as the state of the square, the identification number of the piece located at the coordinate (Piece_ID), the owner of the piece (Owner), the base power (Base_Power), the rank (Rank_Level), and the fatigue index (Fatigue_Index).

[0069] The server organizes this information into a data table format, stores it in a database, and transmits the information to each terminal via the network when both players connect.

[0070] At this time, the transmitted data is sent and received in an encrypted JSON structure, and the terminal interprets it to render the chessboard in a graphic form.

[0071] Along with this, the game preparation department runs a matching engine to match two people in real time among the many users who requested an online match.

[0072] Matching is configured to automatically select the most suitable opponent by considering the player's skill level, network latency, and recent connection status, and once matching is complete, the server generates a unique session identification number (Session_ID) to identify the data for this match.

[0073] The session includes player information, game mode (single move or multiple move), time limit for each turn, initial state of the chessboard (Board_State_Table), and move and collision logs (Game_Log).

[0074] Subsequently, the server transmits a 'game start request' signal to both terminals; upon receiving this signal, the terminals simultaneously load the chessboard interface, store the data received from the server in the cache, and transition to a ready state.

[0075] Once data consistency between the two terminals is ensured, the system transitions to a state where simultaneous movement commands are possible.

[0076] Immediately after the match is complete, the server executes the piece initialization module to automatically place each player's pieces according to traditional chess rules.

[0077] For example, Player 1's pieces are placed in rows 1 and 2, and Player 2's pieces are placed in rows 7 and 8, and the coordinates of each square and the type of piece are stored in a data table.

[0078] At this time, initial combat power and rank information are set for each piece according to its class; for example, a King can be initialized to 100 combat power, a Queen to 80, a Rook to 60, a Bishop to 50, a Knight to 40, and a Pawn to 15. This initial combat power information is used as a reference value to calculate the outcome of a collision later on. Parameters such as the number of moves, fatigue, and the probability of combat power increase or decrease are also stored for each piece. Thus, the server structures the chessboard data to calculate the battle result by reflecting all rank, fatigue, and probability factors when a collision occurs. Specific details regarding this will be described later.

[0079] The game preparation department also performs a data verification routine to check whether the chessboard is configured correctly.

[0080] This routine consists of a procedure to check whether duplicate items exist at each coordinate, whether the item owner information matches, and whether the entire coordinate data is referenced correctly.

[0081] Once verification is complete, the server generates a hash value for the entire chessboard data and transmits it to both player terminals. The terminals compare the hash values ​​received from the server and return a 'Game Ready' signal to the server only if they match.

[0082] This process is a core synchronization procedure that prevents data inconsistencies or transmission errors in advance and enables the two terminals to share a completely identical chess state at the start of the game.

[0083] After such data synchronization is completed, the server transmits a countdown signal to both terminals to signal the start of simultaneous movement-based chess. A preparation time of 3 to 5 seconds is displayed on the terminal screen, during which time the server synchronizes the system times of the two terminals with the reference server time within ±0.1 seconds. This enables the input timing of the two users to be accurately compared down to the minute unit in subsequent turns, thereby substantially implementing the core structure of the present invention known as 'simultaneous movement'.

[0084] At this time, the server corrects the system time error in real time and sends an automatic correction packet to terminals whose network delay exceeds a certain standard (e.g., 200ms), thereby managing the response speeds of both terminals to match.

[0085] In addition, the Game Preparation Department automatically generates a Session Encryption Key for each session to enhance security and stability, and applies this key to all data communications. This key is generated based on the AES-256 algorithm and is discarded immediately upon session termination, effectively blocking external access.

[0086] This security structure prevents game data from being tampered with or manipulated externally.

[0087] Once the game preparation department successfully initializes the data for the chessboard and pieces and all synchronization and verification processes are completed, each terminal visually displays the chessboard through a graphical user interface (GUI).

[0088] Coordinates, icons for each piece, movement ranges, time limits, player nicknames, and session codes are displayed on the chessboard. At this time, each terminal automatically renders the color, border, and highlighting effects of each piece based on the piece attribute information received from the server, and is configured so that the player can intuitively check the status of the pieces on the chessboard.

[0089] This visual configuration goes beyond simply displaying the screen and enhances the accuracy and reliability of simultaneous movement commands by providing a chessboard that perfectly matches the real-time status of the server data.

[0090] Meanwhile, if a network error or data inconsistency occurs during game preparation, the game preparation unit executes an automatic resynchronization routine.

[0091] When an error is detected, the server immediately retransmits the latest chessboard data to both terminals, and the terminals receive it and immediately update their local state. This process can perform up to three automatic retries, and if a persistent error occurs, it can be configured to initialize the session and automatically execute a rematching procedure.

[0092] This automatic recovery function is an important factor in maintaining game continuity and reliability even in unstable network environments.

[0093] As a result, unlike the conventional simple chessboard generation method, the game preparation unit of the present invention includes server-centric data structuring, piece attribute initialization, time and data synchronization, security verification, visual interface initialization, and automatic recovery logic, thereby providing a complete technical environment for a simultaneous movement-based chess game, and at the same time, expands the single-turn structure of traditional chess into a real-time simultaneous input structure to enable the realization of a new type of e-sports chess game.

[0095] The simultaneous movement command receiving unit performs the function of allowing both players to input one or more piece movement commands within the same time limit based on the state of the chessboard initialized in the game preparation unit. This configuration is a network control module implemented to completely break away from the sequential input structure of traditional turn-based chess, enabling the server to accurately receive, analyze, and judge commands even in periods where the commands of the two users overlap in time.

[0096] When a game start signal is transmitted from the server, an input waiting interface is displayed on each player's terminal, along with the remaining time limit, a list of movable pieces, a piece selection window, and moveable coordinate information. Within the time limit, each player can select a desired piece and specify movement coordinates, and these input commands are transmitted to the server. From the moment a player terminal inputs a movement command, the server activates a time synchronization control routine to measure the input times of both terminals in 0.01-second increments relative to the server's reference time, and assigns a unique timestamp to each command. All movement commands consist of information such as the input time, piece type, starting coordinates, and ending coordinates, which are stored in a temporary buffer area. When the time limit expires, the server retrieves the command data from both players simultaneously and integrates them into a single simultaneous movement processing table.

[0097] The server validates the validity of each command based on integrated movement commands and determines whether the path is movable, whether there is duplicate movement to the same coordinates, and whether the movement path collides with the opponent's piece. To this end, the server subdivides the movement path into coordinate units and calculates the probability of collision at the point of passing through each square. For example, as illustrated in Fig. 3, if Player 1's Queen moves from D1 to D4 and Player 2's Rook moves from D7 to D4, the server recognizes the D4 coordinate as a collision point and sets a collision flag on the corresponding data. This collision information is subsequently transmitted to the output unit and used as basic data for determining the win or loss.

[0098] The simultaneous movement command receiver also includes a time limit control module that displays the time limit in a countdown manner from the moment each turn begins, and automatically closes the input waiting state when the time limit expires. A player whose time has expired is considered to have not moved any pieces during that turn, and the server processes this as an automatic stop command. At this time, the automatic stop command is reflected as a consecutive stop count during the fatigue and combat power calculation phases and applied as a rest effect. Therefore, even if no input is made within the time limit, the flow of the game is not interrupted and can automatically transition to the next stage.

[0099] When a player selects the multiple movement mode, which allows moving multiple pieces simultaneously, the server performs piece-specific path validation logic to ensure that the movement paths of each piece do not collide with one another. For example, if Player 1 intends to move a Knight and a Queen simultaneously in the same turn, the server calculates whether the two movement paths intersect, and if the paths overlap, it processes only one command validly according to priority rules. These priorities are generally assigned to pieces of higher rank or commands entered first, thereby preventing unnecessary path collisions or command duplication.

[0100] Meanwhile, even if the movement commands of both players reach the server at almost the same time, the order of arrival may differ due to variations in network latency. Therefore, the server does not execute all commands immediately upon receipt but collects them after setting a buffering period of a certain duration. For example, all commands entered during the 500 millisecond period after the time limit expires are stored, and then reordered based on timestamps and synchronized to prevent unfair input judgments caused by differences in network speed.

[0101] When the buffering period ends, the server performs input synchronization operations to merge all commands within a single turn and simultaneously reflects the movement results of both players on the chessboard. If commands to move to the same coordinates exist, those coordinates are designated as collision coordinates, and data is transmitted so that the output unit can determine this in a subsequent stage. The server simultaneously transmits the results of these simultaneous movement operations to both terminals, and the transmitted data includes the final position of the moved pieces, whether a collision occurred, changes in fatigue, probability of combat power change, and information on the remaining time limit. Based on the received data, the terminal immediately updates the chessboard and switches to a state waiting for input for the next turn.

[0102] In addition, the simultaneous movement command receiving unit of the present invention includes a dual transmission structure to prevent input loss in preparation for network environment instability. Each terminal uses a primary channel and a secondary channel simultaneously when transmitting an input command to a server, and the server determines the command received first among the two channels as a valid command. This structure ensures that input is reflected normally even in situations of communication delay or packet loss, thereby enhancing the fairness and real-time nature of the game.

[0103] Ultimately, the simultaneous movement command receiving unit of the present invention realizes a true simultaneous input structure that could not be implemented in existing turn-based chess systems by including real-time synchronization based on server reference time, timestamp-based command sorting and merging processing, path duplication verification in multiple movement modes, time limit control and automatic stop processing, and dual transmission and exception recovery functions. Therefore, the present invention is not merely a change in game rules, but a technical system implemented through real-time data synchronization between a server and a terminal and a network merging algorithm, providing high fairness and responsiveness in a network-based real-time chess environment. The operational results of this simultaneous movement command receiving unit are used as input for the output unit and combat power calculation module performed in subsequent stages, and are utilized to determine whether there is a collision between pieces and the outcome of the win or loss. Accordingly, the simultaneous movement command receiving unit of the present invention serves as a pivotal component responsible for the core data flow of the game and performs a key role that determines the accuracy and stability of the entire system.

[0105] The output unit determines whether multiple pieces collide at the same coordinates based on the piece movement results of the two players transmitted from the simultaneous movement command receiver, and performs the function of updating the state of each piece by analyzing the results if a collision is detected. This configuration is designed not merely to check for coordinate duplication, but to precisely determine whether a collision has occurred by comprehensively comparing data such as the timestamp, movement path, destination coordinates, and direction of movement for each move, and to reflect the results in the chessboard state data.

[0106] At the end of each turn of the game, the server merges all movement commands received from the two players in chronological order to create an integrated movement table based on the final arrival coordinates of each piece. The output unit analyzes this table to detect whether there are pieces that have moved to the same coordinates. In the collision detection process, the arrival coordinates of all pieces are organized into a hash format, and if two or more entries have the same hash value, they are identified as collision candidates. The server compares detailed data such as the starting coordinates, movement distance, movement direction, and class information of the two pieces based on these collision candidate coordinates, and finally determines whether a collision has occurred.

[0107] When a collision is confirmed, the output unit marks the data at the corresponding coordinates as the "Collision State" and registers the identification information of the pieces involved in the collision in the Collision Info Table. This table includes the collision coordinates, the owner, rank, combat power, distance moved, and time moved of the related pieces, and is used as input data for the win / loss determination algorithm performed in subsequent steps. If there is no collision, the arrival coordinates of each piece are simply reflected in the Board State Table, and the result of the turn is finally determined.

[0108] The output unit is also configured to determine not only movement to the same coordinates but also path collisions. For example, if one piece crosses the path of another piece while moving, the server calculates whether the two paths intersect and determines whether an actual collision has occurred by comparing the chronological order of the intersection points. In this case, the elapsed time of each move is calculated based on the movement distance and piece velocity parameters, and if the two moves intersect within the same time interval, it is determined to be an actual collision. Unlike existing methods that simply compare final coordinates, this path collision detection function considers the temporal progression of the movement, thereby significantly improving the accuracy of real-time simultaneous movement chess games.

[0109] The server updates the state data of each piece after determining whether a collision has occurred. Pieces that have not collided have their state changed to the coordinates where their movement is complete, while pieces that have collided are switched to a provisional state and are temporarily displayed on the chessboard until the result of the win or loss judgment is finalized. At this time, the collision coordinates are visually highlighted on the terminal screen so that the player can immediately recognize whether a collision has occurred.

[0110] The output section can also be implemented using a Priority-based Parallel Processing Structure to handle cases where multiple collisions occur simultaneously. That is, the server separates all collision coordinates into parallel threads to make simultaneous judgments, but controls the system to recognize only the first collision as a valid collision when the same piece is involved in multiple collisions. To achieve this, the server assigns a Time Index to each collision event and processes only one collision based on the earliest time index when the same piece is involved in multiple collisions. Through this structure, the server's computational efficiency can be maintained even when multiple collisions occur simultaneously.

[0111] The output section also includes a verification routine to ensure data integrity and computational accuracy. After collision determination is complete, this routine checks whether duplicate pieces remain at the same coordinates, whether the number of pieces matches before and after the win / loss determination, and whether consistency is maintained between the chessboard state data and the server logs. If an error is detected during the verification process, the server restores the data for the corresponding turn to the snapshot state of the previous turn and re-executes the collision determination calculation. This automatic recovery function effectively prevents inconsistencies caused by transient data errors or delays that may occur in a real-time network environment.

[0112] The output unit finally determines whether each piece has collided and its status, and simultaneously records the results in the chessboard state table and the game log. At this time, the status of each piece is displayed as one of three categories: "Active," "Removed," or "Pending," and the server transmits this information to both terminals simultaneously to update the chessboard screen. The terminals visually reflect the collision results based on the received data, and the player can intuitively recognize the major events of the current turn through the coordinates of the collision.

[0114] In one embodiment, the output unit is configured to determine the winner and loser by applying a collision judgment rule based on the rank of the pieces (hereinafter referred to as the 'rank rule') when the pieces of two players move simultaneously on the same coordinates. This embodiment is designed to maintain the traditional concept of chess ranks while enabling the server to automatically determine collisions between simultaneously input commands and immediately reflect the results on the chessboard, thereby allowing for systematic and fair game progression even in a simultaneous movement structure.

[0115] The server receives all movement command data collected during one turn from the simultaneous movement command receiving unit, merges it into an integrated movement table, and transmits it to the output unit. The output unit first compares the arrival coordinates of each movement command to detect pairs of pieces that have moved to the same coordinates. The detected identical coordinates are marked as "Collision Coordinates," and the information of the two pieces that moved to those coordinates is stored as "Collision Candidate Data."

[0116] The server retrieves the base attribute values ​​of each piece included in the collision candidate data. These attribute values ​​include the piece's type, rank level, owner (Player_ID), move distance (Move_Distance), move direction (Move_Vector), and base power (Base_Power).

[0117] The output unit determines the win or loss using the Rank Level as the highest priority criterion.

[0118] First, if two pieces have different classes, the piece with the higher class rank acquires possession of the collision coordinates.

[0119] The server assigns the 'Win' status to high-ranking pieces and the 'Lose' status to low-ranking pieces, and removes the information of the lost pieces from the chessboard state table.

[0120] As a result, the state of the collision coordinates is updated to the presence of the winning piece, and subsequently, the coordinates are recorded as the location of the winning piece.

[0121] For example, if Player 1's Queen moves to coordinates D4 and Player 2's Knight moves to the same coordinates, the server recognizes that the Queen's rank is higher than the Knight's and determines the Queen as the winner.

[0122] Therefore, the Queen remains at collision coordinates D4, the Knight is removed, and the D4 entry in the chessboard database is updated to "Owner=Player1, Piece_Type=Queen, State=Active".

[0123] Conversely, if two pieces have the same rank, the output unit handles the collision as "Mutual Elimination."

[0124] The server marks the state of both objects as "Removed" and updates the collision coordinates to an empty state.

[0125] For example, if both players move their Rooks to the same coordinates, both Rooks are removed, and the corresponding coordinates on the chessboard remain empty.

[0126] Meanwhile, if either of the pieces that moved to the collision coordinates is a Pawn, the output unit applies an exception rule to remove both pieces.

[0127] Due to the nature of chess, a situation where a pawn collides with a higher-ranking piece is defined as a mutual strike; upon detecting this, the server immediately resets the collision coordinates and removes both pieces simultaneously.

[0128] This rule always takes precedence when the collision coordinates include a pawn, and has a higher judgment priority than other class rules.

[0129] The server transmits these collision determination results to each terminal in real time.

[0130] The terminal updates the chessboard based on the received data, and collision coordinates are displayed through short animation effects or visual highlights (e.g., red border, flashing effect) so that the player can intuitively recognize the collision result of this turn.

[0131] At this time, the server records collision result data in the game log and manages the accumulated movement history and number of collisions of each piece. This accumulated data can subsequently be used for probability and fatigue-based combat power calculations (another embodiment described later).

[0132] The output section is also configured to process all collisions in parallel, even when collisions occur at multiple coordinates simultaneously.

[0133] The server creates a separate thread for each collision coordinate and performs the same class rule determination procedure in parallel within each thread.

[0134] In this case, if the same piece is involved in multiple collisions, the server compares the collision occurrence times (Time Index) to process only the first collision validly, and for subsequent collisions, considers the piece to be inactive to prevent duplicate detection.

[0135] This ensures that the server's computational efficiency is maintained even in multi-collision situations, and the real-time nature of the simultaneous movement structure is not compromised.

[0136] Once all collision detections are complete, the server reflects the collision results in the Board State Table and updates the status of each piece to one of "Active," "Removed," or "Inactive."

[0137] The final state of the chessboard is used as reference data for preparing the game for the next turn, and the server transmits this in synchronization to each player's terminal. This allows both players to input movement commands for the next turn from the same chessboard state.

[0139] In another embodiment, the output unit is configured to determine the winner or loser by comprehensively considering the combat power value, fatigue status, and probability weighting according to the rank of each piece, instead of a simple rank comparison, when two pieces collide at the same coordinates. This embodiment is characterized by advancing the rank-centered decisive judgment structure to the next level so that the player's movement pattern and the state of the pieces substantially influence the battle result, thereby simultaneously improving the strategic depth and game diversity of simultaneous movement chess.

[0140] The output unit receives movement result data from the simultaneous movement command receiving unit and detects two pieces that have moved to the same coordinates. Subsequently, it retrieves the Base Power, number of consecutive moves (n_move), number of consecutive stops (n_stop), Rank Level, Fatigue Index, and Probability Table from the state data of each piece. These data are values ​​that have already been initialized and stored on the server during the game preparation phase, and are updated whenever each turn ends.

[0141] The output unit first calculates the combat power of each unit. The server calculates the current power by applying the fatigue coefficient and rest coefficient to each unit's base power. For example, if the number of consecutive moves (n_move) is 3 or more, the combat power decreases by 10% due to fatigue; conversely, if the number of consecutive stops (n_stop) is 3 or more, the combat power increases by 10% due to the rest effect. These rates of change can be applied as example values, and different probability weights are assigned to each rank.

[0142] At this time, the server runs a Random Number Generator to reference probability weights corresponding to the rank of each piece. For higher-ranked pieces, the probability of combat power decrease is set lower and the probability of increase is set higher, while for lower-ranked pieces, the probability of combat power decrease is set higher and the probability of increase is set lower. For example, the probability of combat power decrease for a King can be set to 10% and the probability of increase to 70%, while for a Queen, it can be set to 20% and 60%; for a Rook, to 50% and 40%; and for a Pawn, to 40% and 60%. The server generates a random number based on the probability distribution for each piece to determine whether a change in combat power will actually be applied, and if the random number falls within the corresponding probability range, the increase or decrease in combat power is executed.

[0143] For example, if Player 1's Rook has high fatigue due to consecutive moves and Player 2's Bishop has remained stationary for two turns, the probability that the Rook's combat power will decrease by 10% due to accumulated fatigue is set higher, while the probability that the Bishop's combat power will increase by 10% due to the rest effect is set higher. The server determines the probability of each piece's combat power change using random numbers to calculate the actual combat power value, and determines the winner by comparing the two values. Consequently, a situation may occur where the Bishop temporarily overwhelms the Rook, which increases the unpredictability and strategic diversity of the game.

[0144] The output unit compares the current power of each piece calculated in this way and determines the piece with the higher value as the winner. If the power is the same, the piece with the higher rank is treated as the winner first; if the rank is also the same, it is treated as mutual elimination. Additionally, if either of the two pieces includes a Pawn, the mutual elimination rule takes precedence, and both pieces are removed from the chessboard. These judgment results are recorded in the server's Collision Result Table, and the result value stores the collision coordinates, win / loss result, power value, fatigue index, and applied probability value.

[0145] For example, assume a case where a collision occurs when Player 1's Rook and Player 2's Bishop move simultaneously on the same coordinate D4. The server refers to the rank, base combat power, number of consecutive moves, number of consecutive stops, fatigue index, and the probability of combat power increase / decrease by rank from the state data of each piece. In the case of the Rook, it belongs to the middle rank, has a base combat power set to 30, and has accumulated fatigue due to moving consecutively for the previous three turns. On the other hand, the Bishop belongs to the upper rank, has a base combat power set to 60, and is in a resting state as it has not moved for the last three turns.

[0146] Under these conditions, the server first calculates the current combat power by reflecting the fatigue and rest coefficients of each piece. Due to the accumulation of fatigue from continuous movement, the Rook's base combat power decreases by 10%, adjusting its combat power to 27, while the Bishop's combat power increases by 10% due to the rest bonus from continuous stopping, raising it to 66.

[0147] Subsequently, the server determines whether the actual combat power increases or decreases by using a random number, referencing the combat power change probability corresponding to the rank of each piece. For the Rook, the probability of combat power decrease is set to 50% and the probability of increase to 40%, while for the Bishop, the probability of combat power decrease is set to 30% and the probability of increase to 50%. The server generates a random number between 0 and 99 for each piece to determine whether the combat power changes according to the probability distribution. For example, if the random number generated for the Rook is 72 and the random number generated for the Bishop is 28, the Rook falls within the decrease probability range, so its combat power decreases by an additional 10% and is adjusted to 24.3, and the Bishop falls within the increase probability range, so its combat power increases by an additional 10% and is adjusted to 72.6.

[0148] The server compares the current combat power adjusted in this way and determines the piece with the higher value as the winner. In the example above, the bishop's combat power is calculated to be 72.6 and the rook's combat power is 24.3, so the bishop wins and the rook is removed from the chessboard. If either of the two pieces had included a pawn, the mutual removal rule would have taken precedence and both pieces would have been removed simultaneously.

[0149] The collision results are recorded in the server's Collision Result Table, which stores the collision coordinates, win / loss results, the final combat power value of each piece, fatigue index, applied probability results, and time information for the corresponding turn. The server transmits these results to each player's terminal to update the chessboard, and the terminal screen displays the winning piece occupying the corresponding coordinates, while the defeated piece is removed with a vanishing effect.

[0150] According to this embodiment, even if the same coordinate collision occurs, the piece with the higher rank does not always win; instead, the outcome may vary depending on each piece's movement pattern, fatigue status, and probabilistic variables. For example, a rook that has performed consecutive moves may lose combat power due to accumulated fatigue, while a bishop that was resting may temporarily gain combat power, allowing it to win the actual collision despite being at a disadvantage in rank. This provides a technical effect that deviates from the deterministic outcome structure of traditional chess games and implements a non-linear and probabilistic combat environment where new combat situations occur every turn.

[0151] In addition, the server accumulates and manages fatigue and combat power data for each piece based on these battle results, and at the end of each turn, recalculates the fatigue and combat power values ​​to reflect them as the initial state for the next turn. Accordingly, instead of continuously using the same piece, players are required to engage in strategic management, such as resting pieces with accumulated fatigue or utilizing other pieces. Consequently, the combat power calculation algorithm according to the present invention goes beyond simple comparison of superiority and implements a real-time state-based probability judgment system in which the player's behavioral patterns are directly reflected in the battle results, thereby providing a technical effect that is qualitatively distinct from existing static chess systems.

[0152] After confirming the collision result, the server updates the Board State Table and marks the state of the winning piece as "Active" and the state of the defeated piece as "Removed". The collision coordinates are updated to the state of possession by the winning piece, and the result is displayed in real time on both players' terminals. The terminals output visual effects (e.g., flashing or color highlighting) at the coordinates where the collision result is displayed so that the user can clearly recognize the collision result of this turn.

[0153] Meanwhile, the server updates the movement history and fatigue index of all pieces at the end of each turn. The fatigue of pieces that have moved is set to increase by a certain amount, while the fatigue of pieces that have not moved is set to decrease by a certain amount. At this time, the fatigue level is managed as a cumulative value, so pieces that have moved continuously for a long period gradually lose combat power, while pieces that have not moved for a long time gradually recover or strengthen their combat power. This data serves to automatically adjust the overall balance of the game, and since players must consider the frequency of use and movement strategies rather than relying solely on rank superiority, the strategic nature of the game is enhanced.

[0154] The output unit also creates independent computation threads for each collision coordinate, even when multiple collisions occur simultaneously, to perform combat power calculations and probability determinations for each piece in parallel. Once all collision determinations are complete, the server merges the results, synchronizes the state of the entire chessboard, and transmits them to both terminals. This parallel computation structure contributes to minimizing computational latency in real-time game environments and maintaining turn-based responsiveness.

[0155] The output unit according to the second embodiment of the present invention, in addition to simple rank-based win / loss determination, probabilistically reflects the activity patterns and state changes of each piece, thereby enabling new combat results to occur every turn in a simultaneous movement environment. Through this, players cannot predict the same result every time, thereby maximizing strategic tension, and at the same time, the server can dynamically maintain game balance through such probability-based calculations.

[0156] Accordingly, the output unit of the present embodiment has the technical effect of simultaneously enhancing the strategic nature, fairness, and unpredictability of a simultaneous movement chess game by including a multidimensional judgment structure that comprehensively calculates the combat power, fatigue, and probability values ​​of a piece, a combat power fluctuation mechanism based on probability weights by class, dynamic judgment processing based on real-time random number generation and server synchronization, and a multi-collision response function through parallel processing.

[0157] The output unit of the present invention, configured as described above, goes beyond simple coordinate duplication detection to precisely determine collisions by comprehensively comparing time, path, and state data, structurally records information regarding each collision in a database, and simultaneously includes parallel computation and verification procedures, thereby enabling stable and fair collision determination even in a real-time online environment. Accordingly, this configuration guarantees the accuracy of the win / loss determination unit and combat power calculation module performed in subsequent stages, and plays a key role in maintaining the logical consistency and technical reliability of the entire game.

[0158] Subsequently, the output unit of the present invention performs the function of reflecting the final calculated win / loss result on the chessboard and, accordingly, synchronizing and updating the state of each piece and game data to automatically reorganize the environment for the progress of the next turn. This configuration goes beyond simply displaying the result on the screen and includes a technical process that verifies, records, and distributes the collision result calculated by the server in real time, and synchronizes it to be completely identical with the screen and internal data of each terminal.

[0159] When the server receives the win / loss result data from the collision judgment unit, it first updates the state for each collision coordinate. Each collision coordinate contains detailed data such as "information of the winning piece," "information of the losing piece," "combat power comparison result," "applied probability value," and "fatigue change value," and the server reflects this in the Board State Table. The winning piece is marked as "Active," the losing piece is changed to "Removed," and the ownership of the collision coordinate is updated to the player of the winning piece. If a mutual removal judgment is made, the corresponding coordinate is initialized to "Empty," and both pieces are removed from the chessboard.

[0160] The server simultaneously transmits these update results to the terminals of both players. The data packets transmitted at this time include the final position of each piece, remaining combat power, fatigue level, movement history, remaining time limit, and win / loss result code; upon receipt, the terminals interpret this information and reflect it in the graphical user interface (GUI). On each terminal screen, the coordinates where a collision occurred are visually highlighted, winning pieces are displayed with short highlight animations or color effects, and defeated pieces are displayed with transparency or disappearance effects. Through this, players can intuitively recognize the result of the current turn, and the server records this display information in a log format so that it can be utilized for playback functions or game review.

[0161] The server updates the state variables of each piece simultaneously with the reflection of collision results. Winning pieces see a slight increase in their fatigue index due to the successful move, while their combat power is maintained at a certain rate. Conversely, the fatigue of pieces that did not move or were not involved in the collision decreases by a certain amount, allowing enhancement effects to be reflected in the next turn. This fatigue update is executed automatically at the end of the turn, and all piece state data is stored in the server's Game_State_DB. The server also separately preserves snapshot data at the end of each turn, enabling its use for recovery in the event of network errors or premature exits.

[0162] Subsequently, the server generates a Game Log based on the win / loss results and the final state of the chessboard. The Game Log sequentially records detailed information for each turn, including command input times, movement coordinates, collision coordinates, combat power fluctuations, win / loss judgment results, fatigue changes, and probability application results. This log remains on the server even after the session ends and can be utilized for game history lookup, AI analysis, and balance adjustments. For instance, the server can learn the frequency of low-probability comebacks in collisions between pieces of the same rank, or patterns where specific pieces win excessively, to incorporate this knowledge into future algorithm corrections. This log management function goes beyond simply storing game results; it serves as a data feedback structure to maintain system performance and fairness.

[0163] When all data is successfully updated, the server sends a "Turn End" signal to each terminal and transitions to the "Input Ready State" for the next turn. During this process, the server resynchronizes the system times of the two terminals to an error range of within ±0.1 seconds and restarts the time limit countdown. Therefore, both players can perform command inputs for the next turn at exactly the same time, which maintains the core prerequisite of the simultaneous movement structure.

[0164] The collision result output section also includes delay compensation and error recovery functions. If the chessboard update is displayed late on one terminal due to network latency, the server sends a priority packet to that terminal to force synchronization of the latest state. Additionally, if data packet loss is detected, the server restores the data by retransmitting the difference data based on a snapshot of the previous turn. These recovery routines maintain the continuity and consistency of the game and ensure that the game continues normally even in environments with unstable network quality.

[0165] When the result output process is complete, the server sends a "Result Confirmed" signal to each player terminal. Upon receiving this signal, each terminal simultaneously switches the chessboard interface to a ready state for the next turn and resets the display of movable pieces and the time limit. When a player is able to input a new move command, the system returns to the routine of the simultaneous move command receiving unit, and the entire game is operated continuously through this periodic cycle structure.

[0166] According to the present invention, a network-based simultaneous piece movement chess game provision system is implemented in which two players move their respective pieces within the same time limit and a server simultaneously determines the results. Accordingly, a real-time interactive game environment, which was impossible in conventional turn-based chess games, is realized, and synchronization between the server and the terminal and the automation of collision detection are achieved, thereby greatly improving the responsiveness and immersion of the entire game.

[0167] First, the present invention resolves the turn waiting problem of conventional chess by adopting a simultaneous input structure and provides an environment where two players can execute strategies in real time. The server sorts each player's movement commands based on time synchronization through a simultaneous movement command receiver and performs a merge operation after the time limit expires, thereby enabling the production of a fair result that does not depend on the order of input. This structure fundamentally eliminates unfairness caused by network delay, input time differences, or asynchronous transmission, and has the technical effect of simultaneously securing real-time performance and equity in a network game environment.

[0168] Second, the present invention resolves logical inconsistencies that occur when multiple pieces move to the same location by having the server automatically detect and process collisions at the same coordinates caused by simultaneous movement. In particular, the rank-rule-based judgment method according to the first embodiment consistently processes collision results based on the rank of the pieces, thereby maintaining clarity in determining wins and losses and the intuitiveness of game rules. Furthermore, by including exception handling rules for collisions between pieces of the same rank or for Pawn pieces, it provides consistent judgment criteria while expanding the rule system of traditional chess. This structure resolves the technical limitations that made real-time collision judgment impossible in existing online chess, and it achieves technical improvements through server-based coordinate calculations and data structuring algorithms, rather than a simple change in game rules.

[0169] Third, the present invention provides a probability-fatigue combined judgment algorithm, thereby ensuring that the outcome of battles within the game is not determined simply by rank superiority, but changes dynamically based on the movement frequency, resting state, accumulated fatigue, and probability of combat power fluctuation of each piece. The server recalculates the combat power value of each piece every turn and controls the probabilistic application of an increase or decrease in combat power according to probability weights for each rank, thereby enabling diverse outcomes even in collisions between pieces of the same rank. This allows for the implementation of probability-based dynamic balancing and a player behavior pattern feedback algorithm, breaking away from the 'deterministic outcome structure' of traditional chess.

[0170] In particular, the server tracks the number of consecutive moves (n_move) and consecutive stops (n_stop) of each piece, applying a decrease in combat power (increase in fatigue) for excessive movement and an increase in combat power (rest reward) for long-term stops. This fatigue-based combat power adjustment mechanism automatically regulates the frequency of piece usage within the game and encourages players to strategically cycle through pieces. As a result, since combat power changes differently depending on the state even for pieces of the same rank, a real-time feedback structure is formed where the player's tactical choices directly influence the outcome.

[0171] Finally, the present invention can perform game balancing at the level of AI computation in real time by simultaneously combining a clear judgment structure based on class with a dynamic computation structure based on probability and fatigue. The server accumulates the results of combat power fluctuations as training data at the end of each turn, and maintains balance by automatically adjusting weights through an internal algorithm when collision patterns under the same conditions are repeated. This self-correcting structure automatically absorbs skill differences, strategic tendencies, and movement patterns among players, and provides technical advantages that allow for the continuous maintenance of fairness and tension even during gameplay.

[0172] In summary, the present invention solves problems such as the limitations of the sequential input structure of existing turn-based chess systems, the inability to process collisions in real time, static win / loss judgment, and network synchronization instability, and achieves technical effects that simultaneously secure real-time, fairness, strategic, and visual consistency through a server-driven simultaneous movement algorithm, collision detection and combined judgment of rank, probability, and fatigue, automatic data update and log-based recovery structure.

[0173] The technology according to the present invention, as described above, may be implemented in the form of program instructions that can be executed through various computer components or implemented as an application, and may be recorded on a computer-readable recording medium. The computer-readable recording medium may include program instructions, data files, data structures, etc., either individually or in combination.

[0174] The program instructions recorded on the above-mentioned computer-readable recording medium are those specifically designed and configured for the present invention, but may also be those known and available to those skilled in the art of computer software.

[0175] Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tapes; optical recording media such as CD-ROMs and DVDs; magneto-optical media such as floptical disks; and hardware devices specifically configured to store and execute program instructions such as ROM, RAM, and flash memory.

[0176] Examples of program instructions include machine code, such as that generated by a compiler, as well as high-level language code that can be executed by a computer using an interpreter, etc. The hardware device may be configured to operate as one or more software modules to perform processing according to the present invention, and vice versa.

[0177] Although the invention has been described above with reference to embodiments, those skilled in the art will understand that various modifications and changes can be made to the invention without departing from the spirit and scope of the invention as set forth in the following claims.

Claims

Claim 1 A network-based simultaneous piece movement method chess game providing system that provides a chess game in which two players matched through an online match move pieces simultaneously and the winner is determined according to predetermined rules, wherein the network-based simultaneous piece movement method chess game providing system comprises: a game preparation unit that places each player's pieces on a chessboard in which a plurality of areas are arranged in two dimensions at each of the terminals of both players matched through the online match so that the chess game is displayed; and a simultaneous movement command receiving unit that receives input for the movement of at least one piece from each of both players within the same time limit.The output unit includes a unit that implements the piece movement results of both players received from the simultaneous movement command receiving unit on the chessboard to update the piece state and simultaneously displays the updated results on the terminal screens of both players. The output unit calculates the respective piece movement paths in coordinate units assigned to the area columns of the chessboard according to the movement commands received from the terminals of both players. In the process of implementing the piece movement results of both players on the chessboard, if a first piece selected by the first player and a second piece selected by the second player move to the same coordinates, it determines that the first piece and the second piece have collided and sets the coordinates of the area where the different pieces collided as the collision occurrence coordinates. The output unit determines the win or loss based on a pre-set rank rule regarding the collision between the first piece and the second piece that moved to the collision occurrence coordinates. If pieces of different ranks collide, it processes it as if the piece of the higher rank moved to the collision occurrence coordinates while removing the piece of the lower rank. If pieces of the same rank collide, it removes both pieces from the chessboard. A network-based simultaneous piece movement chess game providing system, characterized in that if there is at least one Pawn among the pieces moved to the coordinates, both pieces are removed from the chessboard, and the rank rules have priority in the order of King, Queen, Bishop, Knight, Rook, and Pawn. Claim 2 delete Claim 3 delete Claim 4 delete Claim 5 A network-based simultaneous piece movement chess game providing system according to claim 1, wherein the output unit sets a rank and initial combat power for each piece, decreases the combat power when a specific piece moves continuously more than a certain number of times during the chess game progress, increases the combat power when it does not move more than a certain number of times, and determines the win or loss between the pieces based on the combat power assigned to each piece regarding the collision between the first piece and the second piece that moved to the collision occurrence coordinates, wherein the higher the rank of the piece, the lower the probability of the combat power decreasing and the higher the probability of the combat power increasing, and the lower the rank of the piece, the higher the probability of the combat power decreasing and the lower the probability of the combat power increasing. Claim 6 In claim 5, the output unit is characterized by reducing the combat power by 10% when the number of consecutive moves of each piece is 3 or more, and increasing the combat power by 10% when the number of consecutive stops is 3 or more, wherein the King piece has an initial combat power of 100, is set so that the probability of a 10% decrease in combat power when the number of consecutive moves is 3 or more is 10%, and the probability of a 10% increase in combat power when the number of consecutive stops is 3 or more is 70%, the Queen piece has an initial combat power of 80, is set so that the probability of a 10% decrease in combat power when the number of consecutive moves is 3 or more is 20%, and the probability of a 10% increase in combat power when the number of consecutive stops is 3 or more is 60%, and the Bishop piece has an initial combat power of 60, and when the number of consecutive moves is 3 or more, the combat power of Set the probability of a 10% decrease in combat power to 30%, and if the number of consecutive stops is 3 or more, set the probability of a 10% increase in combat power to 50%; for the Knight, set the initial combat power to 50%, and if the number of consecutive moves is 3 or more, set the probability of a 10% decrease in combat power to 20%, and if the number of consecutive stops is 3 or more, set the probability of a 10% increase in combat power to 60%; for the Rook, set the initial combat power to 30, and if the number of consecutive moves is 3 or more, set the probability of a 10% decrease in combat power to 50%, and if the number of consecutive stops is 3 or more, set the probability of a 10% increase in combat power to 40%; for the Pawn, set the initial combat power to 15, and if the number of consecutive moves is 3 or more, set the combat power to decrease by 10% Set the reduction probability to 40%, andA network-based simultaneous piece movement method chess game providing system characterized by setting the probability of increasing combat power by 10% to 60% when the number of consecutive stops is 3 or more.

Images