Abstract:
A method for adapting a game session on a first device for continued play on a second device, the method including establishing a game session on a first device, scaling the functionality of the game within the game session, and continuing the game session with the scaled game functionality on a second device.

Description:
FIELD OF THE INVENTION  
       [0001]     The present invention relates to computer-based games in general, and more particularly to adapting games for operation on multiple computer platforms.  
       BACKGROUND OF THE INVENTION  
       [0002]     Computer games may be played on various types of computer devices, including personal computers, handled PDA devices, and cellular telephones. To adapt a computer game for multiple platforms, computer game developers typically visually reduce the size of game objects for viewing on smaller displays while attempting to preserve full game functionality. Unfortunately, such scaling often does not take into account differences in capabilities between devices.  
       SUMMARY OF THE INVENTION  
       [0003]     The present invention discloses a system and method for adapting a game session on a first device for continued play on a second device.  
         [0004]     In one aspect of the present invention a method is provided for adapting a game session on a first device for continued play on a second device, the method including establishing a game session on a first device, scaling the functionality of the game within the game session, and continuing the game session with the scaled game functionality on a second device.  
         [0005]     In another aspect of the present invention the scaling step includes applying a predefined scaling function.  
         [0006]     In another aspect of the present invention the scaling step includes applying a predefined scaling function that changes any of the number, type, or behavior of any object that is active in the game session  
         [0007]     In another aspect of the present invention the scaling step includes applying a predefined scaling function that changes the gaming environment of the game session.  
         [0008]     In another aspect of the present invention the scaling step includes applying a predefined scaling function that changes a game map of the gaming session.  
         [0009]     In another aspect of the present invention the scaling step includes scaling at the first device before the game session is continued at the second device.  
         [0010]     In another aspect of the present invention the scaling step includes scaling at a server operative to control any of the devices.  
         [0011]     In another aspect of the present invention the scaling step includes scaling at the second device before the game session is resumed thereat.  
         [0012]     In another aspect of the present invention the establishing step includes establishing the game session as a multi-user game session on a plurality of devices, the scaling step includes scaling the functionality of the game within the game session with respect to any of the devices, and the continuing step includes continuing the game session with the scaled game functionality on the devices for which the game functionality was scaled.  
         [0013]     In another aspect of the present invention the game session is active on at least two of the devices, where a first game session object of a first type on a first one of the devices does not affect a second game session object of a second type on a second one of the devices unless the game session on the second device includes at least one object of the first type.  
         [0014]     In another aspect of the present invention a system is provided for adapting a game session on a first device for continued play on a second device, the system including a first device operative to host a game session, and scaling means for scaling the functionality of the game within the game session, and a second device operative to continue the game session with the scaled game functionality.  
         [0015]     In another aspect of the present invention the scaling means is operative to apply a predefined scaling function.  
         [0016]     In another aspect of the present invention the scaling means is operative to apply a predefined scaling function that changes any of the number, type, or behavior of any object that is active in the game session  
         [0017]     In another aspect of the present invention the scaling means is operative to apply a predefined scaling function that changes the gaming environment of the game session.  
         [0018]     In another aspect of the present invention the scaling means is operative to scale at the first device before the game session is continued at the second device.  
         [0019]     In another aspect of the present invention the scaling means is operative to scale at a server operative to control any of the devices.  
         [0020]     In another aspect of the present invention the scaling means is operative to scale at the second device before the game session is resumed thereat.  
         [0021]     In another aspect of the present invention the system further includes a plurality of devices operative to collectively host the game session as a multi-user game session, and scaling means operative to scale the functionality of the game within the game session with respect to any of the devices, where any of the devices for which the game functionality was scaled is operative to continuing the game session with the scaled game functionality.  
         [0022]     In another aspect of the present invention the game session is active on at least two of the devices, where a first game session object of a first type on a first one of the devices does not affect a second game session object of a second type on a second one of the devices unless the game session on the second device includes at least one object of the first type.  
         [0023]     In another aspect of the present invention a computer-implemented program is provided embodied on a computer-readable medium, the computer program including a first code segment operative to establish a game session on a first device, a second code segment operative to scale the functionality of the game within the game session, and a third code segment operative to continue the game session with the scaled game functionality on a second device. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0024]     The present invention will be understood and appreciated more fully from the following detailed description taken in conjunction with the appended drawings in which:  
         [0025]      FIG. 1  is a simplified pictorial illustration of a system for scaling a game&#39;s functionality for different computing devices, constructed and operative in accordance with a preferred embodiment of the present invention;  
         [0026]      FIG. 2  is a simplified pictorial illustration of a system for scaling a multi-player game&#39;s functionality for different computing devices, constructed and operative in accordance with a preferred embodiment of the present invention;  
         [0027]      FIG. 3A  is a simplified flowchart illustration of a method for defining a scaling function, operative in accordance with a preferred embodiment of the present invention; and  
         [0028]      FIG. 3B  is a simplified flowchart illustration of a method for modifying a scaling function, operative in accordance with a preferred embodiment of the present invention. 
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0029]     Reference is now made to  FIG. 1 , which is a simplified pictorial illustration of a system for scaling a game&#39;s functionality for different computing devices, constructed and operative in accordance with a preferred embodiment of the present invention. In a typical game-playing scenario, a user may employ a first device  110 , such as a personal computer, to play a game. The game may reside wholly on first device  110  or alternatively may be played in conjunction with a game server  120 , such as in a network gaming environment, as is well known in the art. Furthermore, the game may be a single-user game, or it may be a multi-user game played with other players.  
         [0030]     At some point after the user has begun to play the game on first device  110 , the user may wish to continue playing the game, being the same game session currently being played on first device  110 , on a second device  130 , such as a hand-held computer. The user may instruct game server  120  to continue the game session on second device  130 , whereupon game server  120  may pause the game session on first device  110  and resume the game session on second device  130 . Game server  120  preferably instructs second device  130  to scale the game functionality appropriately, as is described in greater detail hereinbelow.  
         [0031]     In the example shown in  FIG. 1 , when the user transitions from first device  110  to second device  130 , the game session is modified by scaling the game functionality in accordance with a predefined scaling function. The scaling function may change the number, type (e.g., tank becomes a plane), and/or behavior of any of the objects that are active in the game session, such as reducing the number of tanks and planes active in the game on first device  110  by a factor of 2 while modifying their behavior, such as by allowing them to fire an additional type of missile. In a more complex example, such as is described hereinbelow with reference to  FIGS. 3A and 3B , the scaling function may be calculated based on statistical information gathered while the game is played on first device  110 . Moreover, the scaling function may be dynamic in nature, such as by continually gathering statistical information while the game is being played on second device  130  and continually updating the scaling function with respect to the newly gathered statistics. Additionally or alternatively, the scaling function may change the gaming environment itself, such as the game map. Play of the scaled game session may then continue on second device  130 . At a later time, the user may wish to continue the game session on first device  110 , in which case the objects and/or the gaming environment that is active in the game session on second device  110  may again be changed in accordance with a predefined scaling function. For example, should the user have only one tank left on second device  130  when transitioning back to first device  110 , a second tank may be added to the game, thus scaling up by a factor of 2. Alternatively, the objects previously removed from the game before the first transition to second device  130  may be re-introduced into the game when the returns to first device  110 , such as by increasing the number of tanks to  2  and the number of planes to one.  
         [0032]     The system of  FIG. 1  may be applied to any type of game where the number, type, and/or behavior of any of the game&#39;s elements may be changed. For example, in a poker game the number of computer-controlled players against whom the user plays may be reduced when moving to a platform with a smaller display.  
         [0033]     The game scaling process may be performed by automatic or semi-automatic generation of platform-dependant executable files representing full and scaled-down versions of a game from the same source code, or by dynamic adaptation of the compiled code of a game to a specific computer platform, following identification of the capabilities of the platform, in accordance with conventional techniques.  
         [0034]     Reference is now made to  FIG. 2 , which is a simplified pictorial illustration of a system for scaling a multi-player game&#39;s functionality for different computing devices, constructed and operative in accordance with a preferred embodiment of the present invention. In the system of  FIG. 2  both the first user ( FIG. 1 ) and a second user are playing the same game in a multi-player environment, with the second user playing on a third device  140 . After the first user transitions from first device  110  to second device  130  and his version of the game is scaled, the game preferably is played with the constraint that objects in the more restricted environment are not affected by objects in the less restricted environment unless the objects in the more restricted environment also exist in the less restricted environment.  
         [0035]     By way of example,  FIG. 2  may be extended to a game with three users beginning at a time t 1 , where the goal of each user is to eliminate the objects the other users, the first user transitions to a second device, such as a portable device, at a time t 2 . While the full version of the game may continue as before for the second and third users, each of whom has both planes and tanks, the version of the game that is started on the second device for the first user is a scaled-down version where only tanks are displayed. Given the above constraint, the planes of the second and third users may not affect the tanks of the first user. Also, any hidden objects of the first user in the reduced environment may not be affected by the second and third users acting in the full environment.  
         [0036]     When the properties of the objects of one user change when transitioning from one device to another, the properties of the remaining objects in that user&#39;s new environment may also change in accordance with a scaling factor, as may the objects of the other users who have not transitioned.  
         [0037]     Reference is now made to  FIG. 3A , which is a simplified flowchart illustration of a method for defining a scaling function, operative in accordance with a preferred embodiment of the present invention, and to  FIG. 3B , which is a simplified flowchart illustration of a method for modifying a scaling factor, operative in accordance with a preferred embodiment of the present invention. In the method of  FIG. 3A , a scaling factor which determines how a game is scaled when transitioning between devices is calculated, as is now described with respect to the following elements: 
        a set of the types of the game objects, T={t_ 1 , . . . t_i, . . . , t_I};     a set of the users, P={p_ 1 , . . . , p_n, . . . p_N};     a set of objects currently held by user P, ob(P);     a mapping function of an object to the corresponding element of T, type(ob)     a life function of an object, life(ob), where if life(ob)=0 the object is dismissed from the game;     an attack function act(i,j), which denotes whether the object of type t_i is allowed to attack an object of type t_j where both objects belong to the full game environment. act(i,j) is a binary function, where 1 stands for “true” and 0 for “false”; act(i,j) is preferably represented as an IxI binary matrix, where I is the number of types of objects.     a strike function, strike(i,n,j,m), that denotes the power of the strike of the object of type t_j of player p_n to the object of type t_j of player p_m;     a measure of defense, defense (i,n,j,m), which measures the defense of the object of type t_j of player p 13  m when it is attacked by the object of type t 13  i of player p_n. Note that defense (i,n,j,m) is typically &gt;=1. 
 
 Given the above elements, the reduction in the life function of the object of type t_j of player p_m as a result of the attack by the object of type t 13  i of player p_n may be expressed as: 
 
strike(i,n,j,m)/defence(i,n,j,m) 
 
 Thus, if an object ob 2  is attacked by object ob 1 , life(ob 2 ) may be decreased by strike (type(ob 1 ),n,type(ob 2 ),m)/defence(type(ob 1 ),n,type(ob 2 ),m), yielding function: 
 
life( ob 2)new=life( ob 2)−strike(type( ob 1), n ,type( ob 2), m )/defence(type( ob 1), n, type( ob 2), m )   (F1) 
 
 This may be further simplified using the following abridgments, where 
    attack(i,n,j,m) denotes an attack by an object of type t 13  i of player p_n on an object of type t_j of player p 13  m;     dens(i,n,j,m) denotes the expected probability of the strikes of the object of type t 13  i on the object of type t_j where player t_n attacks player t_m. This function is preferably predefined and may be updated, during the course of the game, using conventional statistical techniques. Note that for any n,m it may be seen that SUM_{i,j}dens(i,n,j,m)=1. 
 
 An auxiliary function M (i,x,j,y) may also be defined such that: 
 
 M ( x,n,y,m )=Sum( dens ( i,n,j,m )) 
 
 where i,n,j,m denote the players and objects types, Sum is taken over the object types i corresponding to the current value of x, and the object types j corresponding to the current value of y, x,y are assigned the values {“full”, “rest”), where x=“rest” denotes the object types presented in the reduced environment for object n and x=“full” denotes the object types presented in the full (i.e. non-restricted) environment but not in the embedded environment for object n, y=“rest” denotes the object types presented in the embedded environment for object m, and y=“full” denotes the object types presented in the full (i.e. non-restricted) environment but not in the embedded environment for object m. 
       
 
         [0048]     These functions may be combined to specify a set of operations related to the transition from a first device to a second device. During transition, the complete set of the types of the game objects, T, may be partitioned into two disjoint subsets: 
 
T=Tr U Tf   (F2) 
 
 where Tr are the object types allowed in the restricted environment and Tf are the object types allowed in the full environment and not allowed in the restricted environment. The condition of such a partition is formulated as follows: 
 
for every type t1 from Tr, an object of type t1 may be attacked by an object of a type t2 from Tr   (F3) 
 
 This may be formalized as follows: 
 
the sub matrix act′ of the matrix act induced by T→Tr contains at least one 1 in each column.   (F4) 
 
 A new matrix actm (i,j) may be constructed, which describes whether the object of type t 13  i is allowed to attack an object of type t_j if one of the objects belong to restricted game environment. This may be implemented as a binary matrix where 1=“true” and 0=“false”. 
 
 The matrix is preferably defined as follows: 
 
act m ( i,j )=act( i,j ), if  i,j  belong to  Tr,  otherwise act m ( i,j )=false   (F5) 
 
 The matrices act and actm represent 2 groups of object pairs: 
 
 E 1 ={i,j |act( i,j )=true and act m ( i,j )=true}
 
 E 2 ={i,j |act( i,j )=true and act m ( i,j )=false}  (F6) 
 
         [0049]     Informally, E 1  represents the types of the attacks enabled in the restricted game environment, whereas E 2  represents the types of the attacks enabled in the full game environment that are disabled if one of the players belongs to the restricted game environment.  
         [0050]     Membership of a pair (i,j) in E 1 , E 2  may be verified by computation of the values actm(i,j), act(i,j)  
         [0051]     A Supplemental Life Updates matrix (SLU) may be constructed for computing updates to the life functions associated with an object. These updates may be used to preserve the user experience after a transition to another device. For each user in a restricted environment, an SLU matrix may be constructed between the user and each other user, such that at least one of the users from the pair of users belong to the restricted environment.  
         [0052]     The SLU matrix is preferably defined as follows: 
 
SLU(i,n,j,m,j′) 
 
 where an additional decrease may be applied to the life function for every object of type j′ of player m when attack(i,n,j,m) is performed. If j′=j, this decrease is in addition to that given by (F1). The function SLU is defined for (i,j) in E 1 . 
 
 This function may be defined as follows: 
 
 SLU ( i,n,j,m,j′ )=SUM e SLU 0( i,n,j,m,e )   (F7) 
 
 Where the sum is taken over e, e runs the object type pairs (i′,j′) belonging to E 2 . 
 
 The function SLU 0 (i,n,j,m, e) may be defined for (i,j) in E 1 , and e=(i′,j′) in E 2  as follows: 
 
 SLU 0( i,n,j,m, ( i′,j′ ))= dens ( i′,n,j′,m )*strike( i′,n,j′,m )/(defenced( i′,n,j′,m ) *A*B ),   (F8) 
 
 where A=SUM dens (k,n,l,m), the sum is taken over (k,l) from E 1 , and B is the number of the objects of type j′ currently held by player m. 
 
         [0053]     Note that SLU(i,n,j,m,j′) may be updated when the number of the object of user m is updated.  
         [0054]     The above algorithm may be appreciated by way of example, as follows.  
         [0000]     At time t 1 :  
         [0000]    
       
          Player  1  owns 2 tanks and 1 plane.  
          Player  2  owns 1 tanks and 1 plane.  
          T={“tanks,” planes”}, I=2  
          P={user 1 ,user 2 }, N=2  
          Ob(user 1 )={“tank 1 ”,“tank 2 ”,“plane 1 ”}.  
          Ob(user 2 )={“tank 3 ”,“plane 2 ”}. 
 
 The values of the life function are as follows: 
 
 For user 1 : 
 
          life(tank 1 )=30;  
          life(tank 2 )=15;  
          life(plane 1 )=15; 
 
 For user 2 : 
 
          life(tank 3 )=60;  
          life(plane 2 )=50. 
 
 The values of the act function are as follows: 
 
          act(tanks,user 1 ,tanks,user 2 )=1;  
          act(tanks,user 1 ,planes,user 2 )=1;  
          act(planes,user 1 ,tanks,user 2 )=1;  
          act(planes,user 1 ,planes,user 2 )=1;  
          act(tanks,user 2 ,tanks,user 1 )=1;  
          act(tanks,user 2 ,planes,user 1 )=1;  
          act(planes,user 2 ,tanks,user 1 )=1;  
          act(planes,user 2 ,planes,user 1 )=1; 
 
 The values of the strike function are as follows: 
 
          strike(tanks,user 1 ,tanks,user 2 )=2;  
          strike(tanks,user 1 ,planes,user 2 )=2;  
          strike(planes,user 1 ,tanks,user 2 )=6  
          strike(planes,user 1 ,planes,user 2 )=8;  
          strike(tanks,user 2 ,tanks,user 1 )=2;  
          strike(tanks,user 2 ,planes,user 1 )=2;  
          strike(planes,user 2 ,tanks,user 1 )=6;  
          strike(planes,user 2 ,planes,user 1 )=10; 
 
 The values of the defense function are as follows: 
 
          defence(tanks,user 1 ,tanks,user 2 )=2;  
          defence(tanks,user 1 ,planes,user 2 )=1;  
          defence(planes,user 1 ,tanks,user 2 )=2;  
          defence(planes,user 1 ,planes,user 2 )=1  
          defence(tanks,user 2 ,tanks,user 1 )=2;  
          defence(tanks,user 2 ,planes,user 1 )=1;  
          defence(planes,user 2 ,tanks,user 1 )=3;  
          defence(planes,user 2 ,planes,user 1 )=2; 
 
 The values of the dens function are as follows: 
 
       
     
         [0090]     dens(*,user 1 ,*,user 2 ):  
         [0091]     dens(tanks,user 1 ,tanks,user 2 )=0.4;  
         [0092]     dens(tanks,user 1 ,planes,user 2 )=0.3;  
         [0093]     dens(planes,user 1 ,tanks,user 2 )=0.2;  
         [0094]     dens(planes,user 1 ,planes,user 2 )=0.1;  
         [0095]     dens(*,user 2 ,*,user 1 ):  
         [0096]     dens(tanks,user 2 ,tanks,user 1 )=0.4;  
         [0097]     dens(tanks,user 2 ,planes,user 1 )=0.1;  
         [0098]     dens(planes,user 2 ,tanks,user 1 )=0.4;  
         [0099]     dens(planes,user 2 ,planes,user 1 )=0.1;  
         [0100]     Two scenarios are now considered. In the first scenario, the game is played within a desktop environment only. In the second scenario, user  1  switches to PDA at time t 1 , and at time t 2  he returns to the desktop environment. The following illustrates preserving the user game experience for transitions to the mobile environment by similarity of the life function in both scenarios at time t 2 .  
         [0000]     First Scenario.  
         [0000]     The users perform the following 20 actions:  
         [0101]     attack(tanks,user 1 ,tanks,user 2 ) - - - 4 times;  
         [0102]     attack(tanks,user 1 ,planes,user 2 ) - - - 3 times;  
         [0103]     attack(planes,user 1 ,tanks,user 2 ) - - - 2 times;  
         [0104]     attack(planes,user 1 ,planes,user 2 ) - - - 1 times;  
         [0105]     attack(tanks,user 2 ,tanks,user 1 ) - - - 4 times;  
         [0106]     attack(tanks,user 2 ,planes,user 1 ) - - - 1 times;  
         [0107]     attack(planes,user 2 ,tanks,user 1 ) - - - 4 times;  
         [0108]     attack(planes,user 2 ,planes,user 1 ) - - - 1 times;  
         [0000]     The attacks occur in the following order:  
         [0000]    
       
          Action 1:  
          tank 1  (of user 1 ) attack tank 3 .  
          By (F 1 ), a new value of life function may be determined as life(tank 3 )=59 
 
 Action 2: 
 
          tank 2  (of user 1 ) attack plane 2 .  
          By (F 1 ), a new value of life function may be determined as life(plane 2 )=48  
          Action 3:  
          plane 2  (of user 2 ) attack plane 1 .  
          A new value of life function may be determined as life(plane 1 )=10  
          Action 4:  
          plane 2  (of user 2 ) attack tank 2 .  
          A new value of life function may be determined as life(tank 2 )=13  
          Action 5:  
          tank 1  (of user 1 ) attack tank 3 .  
          A new value of life function may be determined as life(tank 3 )=58  
          Action 6:  
          tank 3  (of user 2 ) attack tank 1   
          A new value of life function may be determined as life(tank 1 )=29  
          Action 7:  
          tank 1  (of user 1 ) attack plane 2 .  
          A new value of life function may be determined as life(plane 2 )=46  
          Action 8:  
          tank 1  (of user 1 ) attack plane 2 .  
          A new value of life function may be determined as life(plane 2 )=44  
          Action 9:  
          plane 1  (of user 1 ) attack plane 2 .  
          A new value of life function may be determined as life(plane 2 )=36  
          Action 10:  
          tank 1  (of user 1 ) attack tank 3 .  
          A new value of life function may be determined as life(tank 3 )=57  
          Action 11:  
          plane 2  (of user 2 ) attack tank 1 .  
          A new value of life function may be determined as life(tank 1 )=27  
          Action 12:  
          tank 3  (of user 2 ) attack tank 2 .  
          A new value of life function may be determined as life(tank 2 )=12  
          Action 13:  
          tank 3  (of user 2 ) attack tank 1 .  
          A new value of life function may be determined as life(tank 1 )=26  
          Action 14:  
          plane 1  (of user 1 ) attack tank 3 .  
          A new value of life function may be determined as life(tank 3 )=54  
          Action 15:  
          plane 1  (of user 1 ) attack tank 3 .  
          A new value of life function may be determined as life(tank 3 )=51  
          Action 16:  
          plane 2  (of user 2 ) attack tank 2 .  
          A new value of life function may be determined as life(tank 2 )=10  
          Action 17:  
          tank 3  (of user 2 ) attack tank 2 .  
          A new value of life function may be determined as life(tank 2 )=9  
          Action 18:  
          tank 3  (of user 2 ) attack plane 1 .  
          A new value of life function may be determined as life(plane 1 )=8  
          Action 19:  
          plane 2  (of user 2 ) attack tank 1 .  
          A new value of life function may be determined as life(tank 1 )=24  
          Action 20:  
          tank 2  (of user 1 ) attack tank 3 .  
          A new value of life function may be determined as life(tank 3 )=50 
 
 Therefore, at time t 2  the values of life function are as follows: 
 
 For user 1 : 
 
       
     
         [0168]     life(tank 1 )=24;  
         [0169]     life(tank 2 )=9;  
         [0170]     life(plane 1 )=8;  
         [0000]     For user 2 :  
         [0171]     life(tank 3 )=50;  
         [0172]     life(plane 2 )=36;  
         [0000]     Second Scenario.  
         [0000]     The partition (F 2 ) of set T is performed as follows:  
         [0000]    
       
          Tr={“tanks”}, Tf={“planes”}. Thus, the condition (F 4 ) holds. 
 
 The matrix actm may be defined by (F 5 ) as follows 
 
          actm(tanks, tanks)=true  
          actm(tanks, planes)=false  
          actm(planes, tanks)=false  
          actm(planes, planes)=false 
 
 The sets E 1 , E 2  may be defined by (F 6 ) as follows 
 
          E 1 ={(tanks,tanks)} 
          E 2 ={(tanks,planes), (planes,tanks), (planes,planes)}
 
 Compute the value of A which is needed for computation of SLU 0 (*,user 1 ,*,user 2 ,(*,*)): 
 
          A=dens(tanks,user 1 ,tanks,user 2 )=0.4; 
 
 Then, by (F 8 ): 
 
 SLU 0(tanks,user1,tanks,user2,(tanks,planes))=dens(tanks,user1,planes,user2)*2 /A/ 1=0.3*2/0.4/1=1.5 
 
 SLU 0(tanks,user1,tanks,user2,(planes,tanks))=dens(planes,user1,tanks,user2)*3/ A/ 1=0.2*3/0.4/1=1.5 
 
 SLU 0(tanks,user1,tanks,user2,(planes,planes))=dens(planes,user1,planes,user2)*8/ A/ 1=0.1*8/0.4/1=2.0 
 
 Compute the value of A which is needed for computation of SLU 0 (*,user 2 ,*,user 1 ,(*,*)): 
 
          A=dens(tanks,user 2 ,tanks,user 1 )=0.4; 
 
 Then, by (F8): 
 
 SLU 0(tanks,user2,tanks,user1,(tanks,planes))=dens(tanks,user2,planes,user1)*2/0.4/1=0.1*2/0.4/1=0.5 
 
 SLU 0(tanks,user1,tanks,user2,(planes,tanks))=dens(planes,user2,tanks,user1)*2/0.4/2=0.4*2/0.4/2=1.0 
 
 SLU 0(tanks,user1,tanks,user2,(planes,planes))=dens(planes,user2,planes,user1)*5/0.4/1=0.1*5/0.4/1=1.25 
 
 Computation of SLU 
 
 By (F 7 ): 
 
 SLU (tanks,user1,tanks,user2,tanks)= SLU 0(tanks,user1,tanks,user2,(planes,tanks))=1.5 
 
 SLU (tanks,user1,tanks,user2,planes)=SLU0(tanks,user1,tanks,user2,(tanks,planes))+ SLU 0(tanks,user1,tanks,user2,(planes,planes))=3.5 
 
and 
 
 SLU (tanks,user2,tanks,user1,tanks)= SLU 0(tanks,user2,tanks,user1, (planes,tanks))=1.0 
 
 SLU (tanks,user2,tanks,user1,planes)= SLU 0(tanks,user2,tanks,user1,(tanks,planes))+ SLU 0(tanks,user2,tanks,user1,(planes,planes))=1.75 
 
 In time interval [t 1 ,t 2 ] the users performed the following 8 actions which correspond to the actions in the full environment: 
 
          attack(tanks,user 1 ,tanks,user 2 ) - - - 4 times;  
          attack(tanks,user 2 ,tanks,user 1 ) - - - 4 times; 
 
 The actions are performed in the following order: 
 
          Action 1 (=action 1 in the first scenario):  
       
     
         [0185]     tank 1  (of user 1 ) attack tank 3 . 
    By (F 1 ), life(tank 3 ) decreases by 1. 
 
 Additionally, 
   
 
         [0187]     life(tank 3 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , tanks)=1.5;  
         [0188]     life(plane 2 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , planes)=3.5;  
         [0000]     Thus, after the action,  
         [0189]     life(tank 3 )=57.5  
         [0190]     life(plane 2 )=46.5 
    Action 2(=action 5 in the first scenario):    
 
         [0192]     tank 1  (of user 1 ) attack tank 3 . 
    By (F1), life(tank 3 ) decreases by 1. 
 
 Additionally, 
   
 
         [0194]     life(tank 3 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , tanks)=1.5;  
         [0195]     life(plane 2 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , planes)=3.5;  
         [0000]     Thus, after the action,  
         [0196]     life(tank 3 )=55.0;  
         [0197]     life(plane 2 )=43.0; 
    Action 3 (=action 6 in the first scenario)    
 
         [0199]     tank 3  (of user 2 ) attack tank. 
    By (F 1 ), life(tank 1 ) decreases by 1. 
 
 Additionally, 
   
 
         [0201]     life(tank 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0202]     life(tank 2 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0203]     life(plane 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , planes)=1.75;  
         [0000]     Thus, after the action,  
         [0204]     life(tank 1 )=28.0;  
         [0205]     life(tank 2 )=14.0;  
         [0206]     life(plane 1 )=13.25 
    Action 4 (=action 10 in the first scenario)    
 
         [0208]     tank 1  (of user 1 ) attack tank 3  
    By (F 1 ), life(tank 3 ) decreases by 1. 
 
 Additionally, 
   
 
         [0210]     life(tank 3 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , tanks)=1.5;  
         [0211]     life(plane 2 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , planes)=3.5;  
         [0000]     Thus, after the action,  
         [0212]     life(tank 3 )=52.5  
         [0213]     life(plane 2 )=39.5 
    Action 5 (=action 12 in the first scenario)    
 
         [0215]     tank 3  (of user 2 ) attack tank 2 . 
    By (F 1 ), life(tank 2 ) decreases by 1. 
 
 Additionally, 
   
 
         [0217]     life(tank 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0218]     life(tank 2 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0219]     life(plane 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , planes)=1.75;  
         [0000]     Thus, after the action,  
         [0220]     life(tank 1 )=27.0  
         [0221]     life(tank 2 )=12.0  
         [0222]     life(plane 1 )=11.5 
    Action 6 (=action 13 in the first scenario)    
 
         [0224]     tank 3  (of user 2 ) attack tank 1 . 
    By (F 1 ), life(tank 1 ) decreases by 1. 
 
 Additionally, 
   
 
         [0226]     life(tank 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0227]     life(tank 2 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0228]     life(plane 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , planes)=1.75;  
         [0000]     Thus, after the action,  
         [0229]     life(tank 1 )=25.0  
         [0230]     life(tank 2 )=11.0;  
         [0231]     life(plane 1 )=9.75 
    Action 7 (=action 17 in the first scenario)    
 
         [0233]     tank 3  (of user 2 ) attack tank 2 . 
    By (F 1 ), life(tank 2 ) decreases by 1. 
 
 Additionally, 
   
 
         [0235]     life(tank 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0236]     life(tank 2 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , tanks)=1.0;  
         [0237]     life(plane 1 ) decreases by SLU(tanks,user 2 ,tanks,user 1 , planes)=1.75;  
         [0000]     Thus, after the action,  
         [0238]     life(tank 1 )=24.0  
         [0239]     life(tank 2 )=9.0  
         [0240]     life(plane 1 )=8.0 
    Action 8 (=action 20 in the first scenario)    
 
         [0242]     tank 2  (of user 1 ) attack tank 3 . 
    By (F 1 ), life(tank 3 ) decreases by 1. 
 
 Additionally, 
   
 
         [0244]     life(tank 3 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , tanks)=1.5;  
         [0245]     life(plane 2 ) decreases by SLU(tanks,user 1 ,tanks,user 2 , planes)=3.5;  
         [0000]     Thus, after the action,  
         [0246]     life(tank 3 )=50.00;  
         [0247]     life(plane 2 )=36.0  
         [0000]     Therefore, at time t 2  the values of life function will be are as follows:  
         [0000]     For user 1 :  
         [0248]     life(tank 1 )=24.0;  
         [0249]     life(tank 2 )=9.0;  
         [0250]     life(plane 1 )=8.0;  
         [0000]     For user 2 :  
         [0251]     life(tank 3 )=50.0;  
         [0252]     life(plane 2 )=36.0;  
         [0253]     It is appreciated that one or more of the steps of any of the methods described herein may be omitted or carried out in a different order than that shown, without departing from the true spirit and scope of the invention.  
         [0254]     While the methods and apparatus disclosed herein may or may not have been described with reference to specific computer hardware or software, it is appreciated that the methods and apparatus described herein may be readily implemented in computer hardware or software using conventional techniques.  
         [0255]     While the present invention has been described with reference to one or more specific embodiments, the description is intended to be illustrative of the invention as a whole and is not to be construed as limiting the invention to the embodiments shown. It is appreciated that various modifications may occur to those skilled in the art that, while not specifically shown herein, are nevertheless within the true spirit and scope of the invention. For example, it is appreciated that game scaling as described hereinabove may be performed at a first device before the user switches from it to a second device, at a server communicating with the various gaming devices, or at the second device before game play is resumed on it.