Which applications of Artificial Intelligence are most likely to benefit society over the next 20 years?

The classic model for online game’s network is client-server (CS) model. The problems that the model faces are bottlenecks, single points of failure and poor flexibility (Ramakrishna,2006). Peer-to-peer (P2P) model brings another way to structure networks. The problems and shortage of CS model can be solved by some of the P2P models. However, P2P models have shortages like security loopholes that is not researched thoroughly. Also, P2P models are not put into practical use since researches are not enough to support a well-designed P2P structure for online games. This essay focuses on the merits and expectations of using P2P model for online games, including introduction of practical CS models and experimental P2P structures. Furthermore, the limitations and expectations of these P2P structures are discussed.

Although classic CS network structure is popular in online game design, it is facing serious issues of complexity and scalability. A CS network is a network that consists of two parts: clients and servers. For online games, Yahyavi and Kemme (2013) describes the server as machines that contain the master copies of all variable objects and control the game world, and clients as machines to receive information about the game world. Also, clients need to send updates to servers. Most of the existing online games are based on CS network, for example, the famous Massively Multi-player Online Role-Play Game (MMORPG) World of Warcraft is using multiple CS network to support its 12 million subscribed accounts (Liu, et al., 2015). Basic CS models are popular for their simplicity and control efficiency (Yahyavi and Kemme, 2013), although suffering from scalability, error tolerance and cost. Advanced CS model, taking multi-server model as an example, improved its scalability and fault tolerance, but at the price of isolating players in different regions (the players using European servers of World of Warcraft cannot interact with players using Asian servers), complexity and cost. It is clear that the CS model cannot avoid the high cost of servers, as also claimed by Liu, et al. (2015), and cannot fulfill simplicity and scalability at the same time. Also, as Gibson and Vasconcelos (2018) suggested, the CS structure faces the problem of single point of failure, which means the whole network would collapse if the server goes down. Ramakrishna, et al. (2006) also mentioned network throughput bottlenecks and poor flexibility, but the problems are now seen as trivial matters due to high-speed internet and improved network structures. In conclusion, CS networks are well-developed models, yet are facing development bottlenecks.

Researchers are using P2P network to break through the bottlenecks CS networks are facing, yet there exist many challenges for putting P2P network into practical use. P2P network has P2P network is a network in which every machine participates in providing information and calculating data for the whole network (Cassavia, 2018). The role ‘server’ which is played by servers in client-server model is taken by the whole community. Each peer (end device) takes charge of a part of the game world (Yahyavi and Kemme, 2013). The machines are clients and servers at the same time. With the highest potential for scalability, P2P structure can allow any number of players into the game without causing any extra load for the game provider. However, Yahyavi and Kemme (2013) claims that P2P networks face challenges like difficulty in version control, low defense level against malware and cheating. The latter problem is also highlighted by Meng (2018), who designed a model to solve the issue. P2P models in online games are feasible according to various researches with models and relevant tests (Yahyavi and Kemme; Cassavia; Barri, et al., 2016; Gibson, 2018; Liu, et al., 2015), yet are not well-established as runnable game structures.

P2P game architectures have many sorting methods that allow systematic analysis. Yahyavi and Kemme (2013) sorted P2P game architectures into three kinds: structured P2P architecture, unstructured P2P architecture and hybrid P2P architectures. Except for the three kinds of P2P architectures, there exist another kind of P2P structure: hybrid CS/P2P network.

The hybrid CS/P2P model has the most similar structure in P2P networks to CS models, such that the application of this model is highly feasible. Barri, et al. (2014) developed a CS/P2P network structure for MMORPGs. The MMORPG is divided into two parts: main game and auxiliary game. As defined, the main game is a constantly existing game world with lower player interaction, while the auxiliary game is where a few players temporarily gather as a group with dense player interaction. Barri, et al. decided to use CS model for the main game and P2P for the auxiliary game. The two models are combined by a mapping mechanism, which moves the P2P structure among servers in CS model, reducing the redundancy of communications. This model has high flexibility, scalability and efficiency by test, but fails to examine the problems of churns and cheating. Also, this model is only estimated in a single game genre, so its performance in other types of games is unknown.

Pure P2P structures are less familiar, but provide new ways to improve online game architectures. Structured P2P architectures are supported by specific graph structures and mechanisms such as Distributed Hash Table (DHT) that allows every node to send a message to or find other nodes (Yahyavi and Kemme, 2013). Each node is bind with a unique key, such that it could be found, created or deleted with low overhead. Yahyavi and Kemme selected SimMud as an example. Players are distributed into different regions and assigned NodeID. The regions are connected by using ‘the peer with the NodeID closest to the RegionID’ as the leader (Yahyavi and Kemme, pp.18). When a new player joins in, the coordinator who holds the master copy sends its data to the player. When updating the game, the game provider updates the coordinator’s data. The example demonstrates that structured P2P architectures have high efficiency due to their specially optimized connections between nodes, yet fails to examine the problem of malware attack and cheating.

Unstructured P2P architectures provide examples of structures without global mechanisms. Mutual notification system is used instead of global mechanisms in unstructured P2P architectures (Yahyavi and Kemme, 2013). Liu, et al. (2015) described a protocol QuOn based on quad-tree structure. In this model, ‘binding neighbors’ is the key of the mutual notification system. Messages are unicast from one node to another, and nodes are connected through the ‘binding neighbors’ method between neighbors. Backups are needed in case the current quad-tree is lost. Two sets of ‘variable control’ tests have been applied to the model, with results demonstrating high scalability. However, the efficiency is suboptimal and should be further researched. In addition, Liu, et al. did not analyze safety issues, such that this protocol cannot be applied to game applications.

Few P2P models focused on safety issues, because dealing with safety loopholes decrease the efficiency of the models (Meng, 2018). As a solution to the dilemma, Meng created a trust model called speedTrust inspired by the trust relationship between humans. By Yahyavi and kemme’s (2013) definition, speedTrust is also a hybrid (structured combined with unstructured) P2P model. In this hybrid P2P model, super peers are employed to supervise the communication between two nodes, rewarding the regulated peers and punishing malicious transactions using specific formulas. Also, the model abandoned iterative operations and instead use feedback reputations to calculate a peer’s trust value, decreasing the time complexity of the model. This model offers the best solution to the challenges of P2P model considering both efficiency and safety. However, it did not focus on scalability or game adaptability. If able to be combined with the models above properly, this hybrid model could be the perfect solution for peer-to-peer structures for online games.

In conclusion, although research for peer-to-peer network online games exists, there is not a perfect solution for the challenges that peer-to-peer structures face. This essay mentioned four P2P structures: a hybrid CS/P2P method for MMORPG (Barri, et al., 2014); structured P2P architecture SimMud (Yahyavi and Kemme, 2013); unstructured P2P architecture QuOn (Liu, et al., 2015); trust model (also a hybrid P2P model) speedTrust (Meng, 2018). All of the methods solved the single point of failure that client-server model has, and most of the models can scale high and achieve high efficiency. Only one method focused on the safety issues, which are vital for providing safe and fair gaming experience. This method, however, is not applied to games and its scalability is not examined. Without providing an integrated solution to these challenges, the development of P2P online games could be hard and slow.

Reference

Barri I., Roig C. and Giné F. (2016) ‘Distributing Game Instances in A Hybrid

Client-Server/P2P System to Support MMORPG Playability’, Multimed

Tools Appl, 75, pp.2005-2029.

Cassavia N., et al. (2018) ‘Distributed computing by leveraging and rewarding

idling user resources from P2P networks’, J. Parallel Distrib. Comput.,

122, pp.81-94.

Gibson M. and Vasconcelos W. (2018) ‘A Knowledge-Based Approach to

Multiplayer Games in Peer-to-Peer Networks’, Knowledge and Information

Systems. Available at: https://doi.org/10.1007/s10115-018-1295-6

(Accessed: 12 May 2019).

Liu L. et al. (2015) ‘Performance Evaluation and Simulation of Peer-to-Peer

Protocols for Massively Multiplayer Online Games’, Multimed Tools Appl,

74, pp.2763-2780.

Meng X. (2018) ‘SpeedTrust: A Super Peer-guaranteed Trust Model in Hybrid

P2P Networks’, The Journal of Supercomputing, 74(6), pp. 2553-2580.

Ramakrishna, V. et al. (2006) ‘An Active Self-Optimizing Multiplayer Gaming

Architecture’, Cluster Computing, 9(2), pp. 201-215.

Yahyavi, A. and Kemme, B. (2013) ‘Peer-to-Peer Architectures for Massively

Multiplayer Online Games: A Survey’, ACM Computing Surveys (CSUR),

46(1), pp. 1-51.

1