[ieee 2008 5th ieee consumer communications and networking conference - las vegas, nevada, usa...

Impact of Network Loss/Delay Characteristics onConsistency Control in

Real-time Multi-player GamesKaliappa Ravindran

Department of Computer ScienceThe City University of New York

New York, NY 10031, USAEmail: [email protected]

Ali SabbirDepartment of Computer Science

Independent University of BangladeshDhaka-1212, Bangladesh

Email: [email protected]

Balachandran RavindranDepartment of Mechanical Engineering

Rutgers The State University of New JerseyPiscataway, NJ 08854, USA

Email: [email protected]

Abstract— In this paper, we study the impact of network-level message loss/delays on the performance experienced by theplayers in a real-time multi-player game. The study is conductedthrough the prism of consistency models of the game state(logically) shared among the players. We employ a weaker notionof consistency that encompasses: i) the real-time persistenceeffects of player actions in the physical game world; and ii)the state obsolescence caused by the loss/delay of player andgame server messages in the network. Both (i) and (ii) impactthe realism and cohesiveness of the game being played. Theuser-level performance measure, namely, the player-level lag, isstudied for multi-player games under realistic settings of networkcommunications and human participation. Towards this end, thepaper formulated a formal model of multiplayer games and thenstudied the effects of network delays and human persistence onthe player-level lags experienced. Sample games studied are theSoldier of Fortune and the RogueSpear. The methodology can beemployed for studying the the effectiveness of human elementsparticipating in the collaborative simulation of a physical world(such as war games).

Key words: Consistency of game state, replicated window,player asynchrony & lag, peer-to-peer game model, centralizedgame server, network message loss/delays.

I. INTRODUCTION

In a distributed multi-player game, player actions manifestas accessing distinct parts of the game state shared amongvarious players through their workstation windows. The gamestate depicts the objects that represent the simulated physicalworld with which the players interact in real-time. A keyrequirement is that all players see the same local copy of thegame object at any given time. This requirement, commonlyreferred to as WYSIWIS — ‘What You See Is What I See’,should be met in the presence of players modifying the objectat various points in time. Here, the notion of ‘time points’refers to the occurrence of changes from one object stateto another, as perceivable to the participating players. TheWYSIWIS requirement allows maintaining the session focus

because if a player sees a slightly different or out-of-dateversion of the object, it is possible to lose the the session’scohesiveness. The notion of consistency (or player coherence)is thus tied to the copy of game state the players observe attheir local sites and the time durations of these observations.

Here, absolute consistency means that all the players seeexactly the same copy of game state and at the same pointsin time, with the latency experienced by a player being thesame as in a case of directly interacting with the physicalgame world. This leads to a perfect cohesiveness amongplayers wherein every player sees fairness enforced by thesystem relative to the agreed rules of game playing. Thehuman involvement in game playing weakens the consistencyrequirement among players, i.e., a player may tolerate slightly-out-of-date game state at a given time point 1. The incoherenceamong players caused by state divergence and/or delayed stateupdates (say, a player lagging in his/her action longer thanwhat the dynamics of game stipulates) should however bewithin the tolerance limits of players.

The WYSIWIS requirement is influenced by the temporalcharacteristics of player-level actions — which are distinctfrom that in traditional database applications. Some key dif-ferences are the interactive sharing of objects between players(i.e., a player action depends on the most recent game state)and real-time responsiveness of players in a session. One ofthe goals of our paper is thus to study the impact of networkdelays on the interactivity of player actions (referred to asaction latency or lag) in sample games. The study takes intoaccount the property of weak consistency of the game stateshared among players that is feasible in action-based multi-player games2.

In this paper, we achieve WYSIWIS by temporal orderingof player actions that integrates the ‘flow of real-time’ into the

1The weaker consistency allowed in multi-player games is different from acase of updating long-lived objects in a shared window (such as collaborativeediting of a document).

2The weaker consistency requirements on the game state and the pre-definednature of game rules to operate on the game state are the key ingredients ofa system-level execution model of multi-player games — see [6].

This full text paper was peer reviewed at the direction of IEEE Communications Society subject matter experts for publication in the IEEE CCNC 2008 proceedings.

1-4244-1457-1/08/$25.00 © IEEE1128

ordering semantics. The temporal ordering is supplemented bya dead-reckoning mechanism to deal with message loss/delays,which extrapolates the state at a player site when a messagemiss is detected (where possible). Our model thus factorsin the real-time aspects of multimedia gaming in enforcingconsistency among game object instances at prescribed time-points in various player sites (see [11] for the consistencyrequirements on replicated continuous media).

How the real-time constraints on game data are enforceddepends on the network delays incurred on the messagesexchanged between the players and the game server. If thenetwork delays on game data are large, the player actions aremore likely to miss their deadlines or suffer larger latency(i.e., lag). Thus, the ordering of player actions interweaveswith the network delays suffered by messages exchangedbetween the players in a distributed setting, thereby affectingthe cohesiveness of the game. In this light, network servicesthat offer controllable delay/loss behaviors (such as [12]) canbe useful in supporting time-sensitive multi-player games. Thediscussion of game models in the paper however does notpremise on the use of such network guarantees.

The paper is organized as follows. Section II provides aprogrammer’s view of game state updates under timing con-straints. Section III gives a taxonomical view of maintaininggame state consistency in the presence of message loss/delaysin the network. Section IV studies the player lags in multi-player games: SoldierOfFortune and RogueSpear, in terms ofour consistency model. Section V describes related works.Section VI concludes the paper.

II. PROGRAMMING VIEW OF GAME STATE CONSISTENCY

In this section, we capture the relationship between the real-time aspects of player actions and their ordering semantics,in enforcing the consistency of game state. The underlyingprogramming model allows us to study the impact of networkdelays on the player actions. A peer-to-peer communicationstructure where all the players are equals (in terms of theirability to initiate actions) is assumed.

A. Virtual synchrony and real-time

From a distributed programming perspective, the ‘timepoints’ at which player actions take effect correspond to ’vir-tually instantaneous’ operations on the object. This is despitethe fact that in a virtual reality environment, a change in objectstate may be spread out over a certain real-time interval, due topersistence effects of the player actions. Furthermore, a statechange, including updates on the display window, should occurwithin a short latency after the player/computer action causingthe change has occurred in the simulated world. Thus, thereare two system-level requirements:

1) Enforcing the persistence delays of state changes in thecomputer model to match the real-time flows in thephysical world;

2) Reducing the communication delays of action messagesexchanged between the player workstations and the

game server computer over the message transport net-work.

The above guarantees purport to provide the realism of inter-active game playing. In the earlier example of maze game, the(simulated) gun flash on the workstation display as a result ofthe shoot action by a player may occur, say, over a 100 msecduration; and the shoot action should start taking effect within,say, 50 msec ([6] reports similar results for the Quake-IIgame). The time interval of 150 msec since the initiation ofshoot action may however be viewed as a single ‘time point’in a computational model of the game.

B. Existing models of game consistency

Though some existing works on multimedia collaborationtreat user actions as occurring at a single logical time point[1], the computational model in these systems is not basedon a unified paradigm that takes into account the effectsof a passage of time on the shared object state. Existingworks on networked virtual environments [2] deal more withexchanging update messages within stipulated time-intervals,but they do not deal with any computational models that allowan application programmer (who writes the game programs)to incorporate the flow of real-time with ease and flexibility.It is in this light that our paper focuses on a state-machinebased computation model of distributed games.

Any computational model that limits the level of asynchronypossible during a multi-player program execution is not de-sirable for performance and scalability reasons. Consider forinstance, requiring that an action be performed at exactly thesame real-time at every participant (this subsumes a strict or-dering of actions). Though possible with the use of centralizedtime-stamping schemes [1], the solution does not allow theintrinsic tolerance to time differences in the evolution of gamestate to be exploited by the communication system. In theDeltaForce example, players maintain a distributed scoreboardthat indicates the number of points accumulated so far. If twoplayers p1 and p2 shoot a third player p3 at the same time,the model should allow an agreement to be reached amongthe player agents of p1 and p2 as to who shot p3, so that theirscores are consistent. Accordingly, we need distributed objectupdate mechanisms that order the game actions at variousplayer sites consistently, with the real-time interval over whichthe actions are deemed to have taken place being an essentialelement of this agreement.

C. A bird’s view of our approach

Our proposed approach requires a state-machine basedprogramming view of shared game objects. In this view, aplayer action causes a change in the game object relative to itscurrent state, with the commit of a state change occurring overa prescribed real-time interval. To accommodate spontaneouslyemanating player actions based on a current state of the gameobject, the paper introduces a notion of temporal epoch, whichis the time interval over which an agreed set of player actionscan commit (all copies of the game object are consistent atthe end of an epoch). The agreement condition is determined


1129

computer

controlling

monster

shoot(a,a)

shoot(b,a)

move(b,a

)

shoot(b,b)

abortcommit

(a,a)

(b,a) (b,b)

(a,b)

commit

player 2

scores !!

player 1

misses !!

hit point

hit point

netw

ork

dela

y

(cau

ses p

lay

lag

)

too

mu

ch

netw

ork

dela

yla

g i

n p

lay

commit

TIME

monster

EP

OC

H-x

EP

OC

H-y

EP

OC

H-z

EP

OC

H-u

player1 player 2 player3

Fig. 1. Illustration: Impact of message delay/loss on game state

by subjecting the object through a sequence of state changesby application-supplied ‘state transition’ functions.

To protect against message loss and excessive delays, weemploy dead-reckoning techniques to update the state at aplayer site if a message miss is detected at this site. Ifthe player controls the movement of an avatar, the stateextrapolation can be by linear predictions of the motion. Inother cases where extrapolation is not feasible, a state updatemay not occur. For instance, the state in the previous epochmay simply be re-used; it will then appear as if the player doesmake note of the event that the other players have seen. Theinconsistency will be corrected in a subsequent epoch whenmessage delivery is successful. In any case, it is possible thatthe state will diverge over short intervals of time, but the statewill converge eventually to a value consistent with that at theother player sites.

D. An illustration of our approach

Figure 1 illustrates our approach with a sample scenario inthe earlier example of multi-player maze game. A computerprogram controls the movement of monster over a 2×2 gridlabeled as (a, a), (a, b), (b, a), (b, b). Three players attempt toshoot the monster with spontaneous actions based on themonster location. There are four epochs x, y, z and u, witheach epoch committing exactly one player action. At the startof epoch-x, the monster is in location (b, b), and the actionof player 1 to shoot at (a, a) commits while that of player 2to shoot at (b, b) aborts. The result is a miss by player 1; the

player 2 action could not commit due to the excessive messagedelay suffered in the network — even though it was accuratelyaimed at the monster. In epoch-y, the computer program movesthe monster to the grid (b, a). This, being the only actiongenerated in epoch-y, commits since the message delays areless than the allowed interaction latency in the game. Likewise,the player 2 action to shoot at (b, a) commits in epoch-z. Thisaction causes a hit on the monster, which causes the gamestate to be updated accordingly (i.e., player 2 scoring a win)at the start of epoch-u.

If, for instance, the state update does not occur at player 3site in epoch-z, say, due to a loss of the message move(b, a),the player 3 will continue to see the monster in grid (b, b) —whereas the other players see the monster moved to grid (b, a).The state at player 3 will possibly be updated in epoch-u whenthe monster movement to the grid (b, a) and the shooting ofmonster by player 2 in this grid appear to have occurred inthe same epoch-u. In player 3’s view, the commutative natureof the two simultaneous actions appears to yield the combinedresult of the monster being shot by player 2.

As can be seen, the spontaneity of players is captured ineach epoch, in that the aborted shoot action of player 2 inepoch-x is not re-executed — even though the monster inposition (b, b) was aimed at correctly. Without any memory ofhis/her prior actions, the player 2 again attempts to shoot inepoch-z but now based on the new location of monster thatwas committed by the player actions in epochs x and y.

Our consistency model offers the potential to exploit thefine-grained asynchrony possible in the human-oriented dis-tributed game settings, which allows reaping higher executionperformance (namely, lowering the synchronization overheadand reducing the lag experienced by players)3. To assess thispotential, our paper studies the impact of network-inducedmessage loss/delays on the execution of representative multi-player games.

III. CONSISTENCY MODELS INTERWEAVED WITH

NETWORK CHARACTERISTICS

Any computational model to enforce state consistency in amulti-player game involves the flow of player-initiated mes-sages through the network that cause correct state updates at allthe player sites within prescribed time intervals4. Consider, forinstance, two models to enforce consistency. One, employingan ordered multicast delivery of player messages to updatethe game state by low-level message retransmissions in thepresence of message loss/delay. Two, employing an unreliablemulticast that is supplemented with dead-reckoning techniquesto extrapolate the game state at a player site when messages tothat site are lost or excessively delayed. Both these techniquesshould be augmented with the notion of ”passage of real-time”to accommodate the real-time nature of multi-player games.

3Our approach also offers flexibility in the construction of distributed gameprograms, due to the uniformity in communication structures and the well-established state-machine paradigms on which it is founded.

4See [10] for a survey of the issues of state consistency and playerresponsiveness arising due to the network characteristics.


1130

In the case of totally ordered multicast, a sustained messageloss or excessive message delay at a player site can causethe game state to be not updated at the other sites because ofthe strong consistency requirements underlying the model. Thecase of dead-reckoning techniques is meaningful in games thatinvolve movement of avatars, and may employ linear motionpredictors based on the current location and speed of the avatarcontrolled by the player.

The total ordering approach incurs a large control messageoverhead (such as synchronization and commit messages) atthe end of each round of player interactions with the gameworld. Also, the number of missed rounds of state update canbecome unacceptably high as the message loss/delay increases(the work [6] reports a 8% miss rate at the player sites inQuake-II under a 5% message loss condition of Internet andwith 10 players). Thus, the technique does not scale well withthe number of players in the game. The unreliable multicastapproach still involves the buffering of player messages atreceiver sites and determining a commit order of messagestherein to update the game state, with dead-reckoning resortedto when the miss of an update message is detected. This mech-anism also does not scale well with the number of players,because the ordering of commits assumes a tight-couplingamong the player actions — which often does not exist inaction-based multi-player games. So, both the approaches donot lend well to capture the spontaneity of player actions.

In the above light, our model of enforcing game consistencyexplicitly accommodates the spontaneity in the generation ofplayer actions5. The model involves committing one or morenon-conflicting actions in every round of player interactions,with the notion of conflicts determined by the intended statechanges on the virtual world. A player message that is lost(or excessively delayed) in the network will be treated by thesynchronization protocol as if the player chose not to generateany action at all in that round. From the player standpoint, thenon-commit of his/her action in a round does not cause muchannoyance because of the player ability to interact with thevirtual world in subsequent rounds and have his/her actionscommitted therein. This aspect of our model to accommodateplayer spontaneity makes our approach scale well with thenumber of players.

Optimistic techniques to (pre-)commit the game state, sup-plemented by state rollbacks when necessary, have also beenstudied for multi-player games to reduce synchronizationlatency [13]. These techniques are based on the currentlyprevalent notions of causality relations between actions andthe ability to detect causality violations after a (pre-)commit6.The techniques premise that message loss is small and messagedelays are more or less constant, under normal operatingconditions of the network. An extended form of the optimistictechniques can be used in the synchronization protocol under-lying our model too, with appropriate modifications to handle

5That a player chooses to not take any action in a particular round issubsumed as a part of the notion of spontaneity accommodated in our model.

6Note, the actual commit of state in the virtual world cannot happen untilthe potential causality violations are checked by the optimistic scheme.

the spontaneous generation of player actions.It is through such consistency models that we study the

impact of network-level message loss/delays on the user-levelperformance in time-sensitive multi-player games.

IV. OUR EXPERIMENTAL RESULTS ON SAMPLE GAMES

We studied a fast multiplayer game by Raven Softwareplayable over WON.NET: the Soldier of Fortune (SOF)and the RogueSpear. The study focused on the effect ofsynchronization delays (i.e., epoch durations) on the user-levelperformance (which subsumes the effect of network delays).

A. Structure of game performance measurement system

The currently available multi-player games employ a centralserver to which the player stations communicate over theInternet. A game session consists of one or more playersinteracting with the game server. Besides maintaining thegame state and running the state synchronization protocolsfor the players stations, the game server also runs a computerprogram, where necessary, that randomly controls the gameobjects accessed by the players as part of the game semantics.

The game server maintains the game state for each activesession. A player joins a game session by indicating thesession name that was created at the start. This session name isbound to the set of unicast paths set up from the player stationsto the server and to the multicast path set up from the serverto the player stations. See Figure 2 for an illustration7. Theunicast paths are typically TCP/IP-based end-to-end transportconnections, whereas the multicast path is based on the ’IPmulticast group’ mechanism. These paths carry the playeractions messages and the server control messages as part ofthe state synchronization protocol. The messages are subject todelays that are inherent in the Internet transport mechanisms.The impact of these delays on player-level lags experiencedin their actions is the goal of our measurements.

Though the game server does not explicitly implement ourmodel of object consistency on the game window, the Internet-delay based lag measurements does provide us with a referencebenchmark in terms of which our model can be evaluated withextrapolated measurements.

B. Sample measurement results: Soldier of Fortune

It was timed how long the delay is for a shot from a pistol tohit the floor directly underneath a player’s character comparedwith the delay of a burst of five shots from an automaticweapon. Since the floor is right under the player, the shotsshould make the appropriate decal or damage marker almostimmediately. One game session was played, with testing offive pistol shots and then five bursts from an automaticweapon. Figure 3 shows sample experimental results. Theuser-level latency was measured as ranging between 0.3 secto 0.6 sec. This level of latency, though noticeable, lies withinthe acceptable latency behaviors for this type of games.

7Though the measurement system employs a game server accessed by clientstations (i.e., the players), the user-level model is based on a peer-to-peercommunication relationship among the players (namely, any player can initiatean action on the game window).


1131

GAME SERVER

player 1

station

player 4

station

player 3

station

player 2

station

player 5

station

internet

unicast paths

to server

internet

multicast path

from server

COMMUNICATION

STRUCTURE

discard

choose z(3)compute s= [z(3)]

action-x(1,e)

action-z(3,e)

update_game_state(s)

s ss

s

s

ep

oche

TIME

global state

update point

lag

in

pla

yer

actio

n d

ue t

o

netw

ork

dela

y

action-y(1,e)

TIMING

SCENARIO

game serverplayer 1 player 2 player 3 player 4 player 5

Fig. 2. Structure of performance measurement system for multi-player games

Lag Determined by Type of Weapon

0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

1 2 3 4 5

TEST NUMBER

La

g(s

ec

)

Pistols

Automatic

Fig. 3. Experimental results for ’Soldier of Fortune’ game

The automatics cause more of a delay than the pistolsbecause of the amount of data being transferred in messages.When a weapon is fired in the game, the information istransferred to the server and then distributed to the otherplayers. With a pistol, there is a minimal amount of data beingsent. There is the muzzle flash of the gun (in game lighting),the bullet hole, or in case of a player being hit, splatters ofblood on the floors, walls, and bodies, etc. With the automaticweapons, the same variables are involved but have higher rateof changes in values (e.g., instead of having one bullet holeshown, one might have ten bullet holes that are all sent to theserver and then the players.

Amount Of Lag in "Rogue Spear"

0

10

20

30

40

50

60

1 2 3 4 5

# of Games

La

g T

ime

(s

ec

)

Lag for Big Games

Lag for Small Games

Fig. 4. Experimental results for ’RogueSpear’ game

C. Sample measurement results: RogueSpear

In RogueSpear, all players are connected to the game serveror to the player hosting the game. The latter contributes anadditional source message delays — and hence player-levellags.

In the ”RogueSpear” game, the player-level lags are quitelarge: they range from 1 sec for small games (3-4 players)to 4-5 sec for larger games (8-10 players). See Figure 4. Theproblem of higher latency arises because some players mightnot have a very fast connection speed (say, a 54 kbps phonemodem), which in turn, affects the other players. We testedfive different matches with a fast host (green bars are shownin the Zone for fast servers) and eight or more people playingfollowed by five matches with less than eight people playing.

There is significantly more lag in larger games than insmaller games. The reason is that with more players, it ismore likely that at least one of them has a slow connection.The major problem with this is that the lag makes the gamenearly unplayable. The players tend to warp all over the map,which makes things confusing for them. Players who thinkthey are shooting other players could, in reality, be shootingat a wall. As one player’s data is being transmitted to theserver and then to another player, the first player might bemoving somewhere else. This might not be so bad but in agame such as ”Rogue Spear”, a player only has one life andit is annoying for a player to have to wait for the game to endbecause he/she warped into the crossfire of a big gun fight.

Though our measurement results are quite tentative, theyshed insight into the player-level latency in having their actionstake effect on the shared game window. The impact of theobject consistency model employed by the synchronizationprotocol is captured in the measured lags.

V. EXISTING STUDIES OF GAMES UNDER NETWORK

LOSS/DELAYS

Multi-player games such as First Person Shooters andReal-Time Strategy embody different inter-player interaction


1132

models — hence exhibit different levels of susceptibilityto system-induced latency. For instance, [3] reports somestatistical correlations between the user-level performance andthe system latency in Warcraft-III. The work reports that boththe lagged and non-lagged players see events in real-time 8 andthat inconsistent game states are rare (so dead-reckoning andpredictions are less). Since Warcraft-III is a strategy-orientedgame (unlike a movement-intensive FPS game), the outputresult of a Warcraft-III run is thus not much affected by along latency.

The Ph.D. thesis of T.N.H. Henderson [9] considers theimpact of two types of delays: an absolute delay (i.e., thedelay between when a player initiates his/her action to whenthe player sees the effect of that action on the shared window)and a relative delay (i.e., the lag experienced by a user relativeto the lag experienced by other players). The work measuresthese parameters for a FPS game, HalfLife, played over theInternet that does not offer any delay guarantees. The workconcludes that the players cannot distinguish relative delaysbut are sensitive to the absolute delays. This HCI-orientedquality specs allows a system designer to focus on reducingthe message transport delays to the game server, rather thanthe coordination latency among players.

[5] studies the fairness among players in the presencedelay/loss-induced lag in the players’ views. Unfairness is saidto occur when a player’s local context indicates that he/shehas carried out an action on the shared game window but thesystem assigned credit for that action to a competing player.The wrong assignment of credit for the action may arise dueto state inconsistencies caused by message loss/delays9. Theunfairness is however over short time-scales only, with eachplayer suffering an equal amount of unfairness over longertime-scales — assuming that the randomness in messageloss/delay behavior of the network is the same at every playersite.

As can be seen, the impact of message loss/delays on theuser-level performance is different for various types of games.This is because the time-sensitiveness of player actions isdifferent in the FPS, RTS, and role-playing type of games10.

VI. CONCLUSIONS

In this paper, we studied the impact of network delayson the performance experienced by the players in a multi-player game. The study was conducted using a systematic

8A lagged player however delays the execution of his/her event by anamount equal to the induced latency.

9Refer to the scenario discussed in section II-D where the computer-generated message move(b, a) is lost at player 3’s site during epoch-z, leavingthe monster in grid (b, b) as per player 3’s view — whereas the monster ismoved to grid (b, a) as per other players’ views — c.f. Figure 1. Supposeplayer 3 shoots in the grid (b, b) at the start of epoch-u, in addition to theplayer 2 shooting in the grid (b, a). Here, the player 3 suffers an unfairnessbecause the local context indicates (incorrectly) that he/she was denied thecredit of shooting the monster.

10Studying the impact of network loss/delays on the user-level performanceof multi-player games allows a suitable provisioning of the infrastructureresources (i.e., network bandwidth and game-station play-out buffers) [4].

model of maintaining object consistency on the game window(logically) shared among the players.

The model of object consistency underscores two key el-ements: i) real-time persistence effects of player actions inthe physical world; and ii) the delays on the player andgame server messages caused by the network communications.Both (i) and (ii) impact the realism and cohesiveness ofthe game being played — so that the effectiveness of thehuman elements participating in the collaborative simulationof the physical world can be ascertained. Studying the delayelements, which we refer to as player-level lag, requires astudy of multi-player games under realistic settings of networkcommunications and human participation. Towards this end,the paper formulated a formal model of real-time multiplayergames and then studied the effects of network delays and user-level persistence on the overall player-level lag experienced.Sample games studied are the Soldier of Fortune and theRogueSpear.

Besides multi-player games with entertainment goals, ourstudy is useful in other application settings as well: such asmilitary war games simulations and virtual reality human-in-the-loop immersions.

REFERENCES

[1] R. Strom, G. Banavar, K. Miller, A. Prakash, and M. Ward. Concur-rency Control and View Notification Algorithms for CollaborativeReplicated Objects. In IEEE Transactions on Computers, vol.47, no.4,pp.458-471, April 1998.

[2] Stone, Steve, Zyda, Michael , Brutzman, Don and Falby, John S. MobileAgents and Smart Networks for Distributed Simulations. In Proceed-ings of the 14th DIS Workshop, 11 - 15 March 1996, Orlando (FL).

[3] N. Sheldon, E. Girard, S. Borg, M. Claypool, and E. Agu. The Effect ofLatency on User Performance in Warcraft III. In proc. NetGames’03,ACM SIGCOMM, Redwood City (CA), May 2003.

[4] F. Safei, P. Boustead, C. D. Nguyen, and M. Doelatshahi. Latency-drivenDistribution: Infrastructure Needs of Participatory EntertainmentApplications. In IEEE Communications, pp.106-112, May 2005.

[5] A. Le and Y. E. Liu. Fairness in Multi-player Online Games onDeadline-based Networks. In proc. Consumer Communications andNetworking Conference, IEEE-CCNC2007, Las Vegas (NV), Jan.2007.

[6] A. Bharambe, J. Pang, and S. Seshan. Colyseus: A Distributed Archi-tecture for Multiplayer Games.. In proc. Networked Systems Designand Implementation(NSDI’06), ACM/SIGCOMM-SIGOPS & USENIX,San Jose (CA), May 2006.

[7] T. Henderson and S. Bhatti. Modeling User Behavior in NetworkedGames.. In proc. Multimedia (MM’01), ACM/SIGMM-SIGCHI, Ottawa(Canada), pp.212-220, Oct. 2001.

[8] L. Gautier and C. Diot. Design & Evaluation of MiMaze: a MultiplayerGame on the Internet.. In proc. Intl. Conf. on Multimedia ComputingSystems(IMCS’98), IEEE-CS, Austin (TX), pp.233-236, July 1998.

[9] T. N. H. Henderson. The Effects of Relative Delay in NetworkedGames. In Ph.D. Thesis, Computer Science, Univ. College London, Febr.2003.

[10] J. Smed, T. Kaukoranta, and H. Hakonen. A Review of Networkingand Multiplayer Computer Games. In Technical Report, TR 454, TurkuCentre for Computer Science (Finland), April 2002.

[11] M. Mauve and et al. Local-Lag and TimeWarp: Providing Consis-tency for Replicated Continuous Applications.. In IEEE Transactionson Multimedia, vol.6, pp.47-57, Febr.2004.

[12] B. Field, T. F. Znati, and D. Mosse. V-NET: A versatile NetworkArchitecture for Flexible Delay Guarantees in Real-time Networks.In IEEE Transactions on Computers, Vol.49, No.8, pp.841-858, Aug.2000

[13] S. Ferretti and M. Roccetti. Fast Delivery of Game Events with an Op-timistic Synchronization Mechanism in Massive Multiplayer OnlineGames.. in proc. Intl. Conf. on Advances in Computer EntertainmentTechnology (ACE 2005), ACM-SIGCHI, Valencia (Spain), pp.405-412,June 2005.


1133

[ieee 2008 5th ieee consumer communications and networking conference - las vegas, nevada, usa...

Documents