U.S. Pat. No. 9,017,170

DETAILED DESCRIPTION OF ONE OR MORE EMBODIMENTS

FIG. 1depicts a prior art system in which exemplary computing devices30and40are coupled to server20across network10. Computing devices30and40each can be a desktop, notebook, server, mobile device, or any other type of device with network connectivity. Network10can be a LAN, WAN, the Internet, or any other type of network. Computing devices30and40and server20each are coupled to network10using wired connections (such as Ethernet, DSL, cable modems, or other known wired connections) or wireless connections (such as 802.11, CDMA, EDGE, EV-DO, or other known wireless connections). Notably, in this prior art system, all communication between computing device30, computing device40, and server20occur using a common protocol, such as HTTP or an API.

FIG. 2depicts an embodiment of the present invention. Computing device130is coupled to server122over network100. Computing device140is coupled to server124over network100.

In this example, computing device130is a PC running a first platform, such as the facebook environment. Server122is configured to communicate with computing devices running the first platform, such as computing device130. For example, server122can be configured to communicate using facebook APIs with computing devices running the first platform.

Computing device140is a mobile device running a second platform, such as an iPhone application or Android® application. Server124is configured to communicate with computing devices running the second platform, such as computing device140. For example, server124can be configured to communicate using a proprietary API with computing devices using the second platform. Server122and server124are coupled to server120.

In this embodiment, User A (the user of computing device130) and User B (the user of computing device140) are able to play an interactive game together. With reference now toFIG. 3, the same structures fromFIG. 2are shown. Computing device130creates and stores data structure201for User A, and computing device140creates and stores data structure301for User B. Server122creates and stores data structure202for User A, and server124creates and stores data structure302for User B. Server120creates and stores data structure203for User A and data structure303for User B. Each of these data structures comprise common fields and sub-fields, such as the fields and sub-fields shown in Table 1:

TABLE 1FIELDSSUB-FIELDSData structure IDUser IDName, Email address, PhotoGame IDTimestamp of last datastructure updateStatus of Game ProgressLevel, Points, Items ObtainedIn-Game PurchasesAmount of purchase, timestamp of purchase,item purchase, status of use of purchase withingameIn-Game VirtualAmount, timeline of use of currencyCurrencyOther PlayersFor each other player: User ID, Data StructureID, Status of Game Progress (and sub-fields)

Optionally, data structures202,203,302, and303can be tables in a database, such as a MySQL database, wherein the key is the Data Structure ID, Game ID, or User ID. The database storing data structure202can run on server122, the database storing data structure302can run on server124, and the database or databases storing data structures203and303can run on server120. Optionally, data structures201and301can be tables in databases running on computing device130and computing device140, respectively.

Referring now toFIG. 4, the initiation of an interactive game in an embodiment will now be discussed. In this example, computing device130, at User A's instruction, requests a new game to be created by sending a message to server122, and computing device130creates data structure201(step400). Server122then creates a new Game ID and data structure202(step405). Server122sends a message to server120that the new Game ID has been created and that data structure202has been created (step410). Server120then creates data structure203and populates the fields and sub-fields (step415). Server120and server122then synchronize data structure203and data structure202using the synchronization process described below (step420). Server122and computing device130then synchronize data structure202and data structure201using the synchronization process described below (step425).

With reference now toFIGS. 5A and 5B, adding an additional player to the interactive game described previously with reference toFIG. 4will now be discussed. In this example, computing device130, at User A's instruction, submits a request to server122to invite User B to the interactive game (step450). Server122submits the request to server120to invite User B (step455). Server120then sends a request to User B to join the game (step460). This request can be by email, SMS or MMS text message, an API sent directly to an application running on a computing device associated with User B, or another communication mechanism. User B then accepts the request using computing device140(step465). The acceptance can be made by selecting a web link, responding by email, responding by SMS or MMS text message, selecting a button within an application, or any other communication mechanism. Computing device140transmits the acceptance to server124(step470). Server124transmits the acceptance to server120(step475). Server120creates data structure303and updates data structure203(step480). Server120and server122synchronize data structures203and202(step485). Server122and computing device130synchronize data structures202and201(step490). Server124creates data structure302based on data structure303, and computing device140creates data structure301based on data structure302(step495).

In this example, server122communicates with computing device130using a first API (such as the facebook API), and server124communicates with computing device140using a second API (such as a proprietary API designed for use with an iPhone or Android device as the case may be). Server122and server124can communicate with server120using the first and second APIs, respectively, or using a third API or protocol (such as an API for inter-server communications).

An embodiment of a synchronization process will now be discussed. In the embodiments described thus far, data structures201,202, and203correspond to user A, and data structures301,302, and303correspond to User B. Optionally, server120can create and store a master game data structure400for the game that User A and User B have joined. Master game data structure400can contain the same fields and sub-fields describe previously for data structures201,202,203,301,302, and303.

During game play, User A will interact with computing device130and User B will interact with computing device140. Computing device130runs local application135(not shown), and computing device140runs local application145(not shown). Local application135will update data structure201as User A progresses through the game. Local application145will update data structure301as User B progresses through the game. User A and User B need not necessarily be playing at the same time.

In the situation where User A is playing the game, periodically (such as every 100 ms) computing device130will send a synchronization request to server122. The request will contain a timestamp. If that timestamp indicates a later time than the timestamp in data structure202, then data structure202will be written over with the data from data structure201as to fields and sub-fields that have changed and the timestamp field of data structure202will be updated with the timestamp in the initial request from computing device130. However, if the “Other Players” field and sub-field of data structures201and202do not match, then the “Other Players” field and sub-fields of data structure201will be overwritten with the data from data structure202, because this mismatch would only occur if the status of other players had changed since the last synchronization event, in which case data structure202would contain the more recent data for the “Other Players.”

Periodically, server122will send a synchronization request to server120. If the timestamp of data structure202indicates a later time than the timestamp in data structure203, then data structure203will be written over with the data from data structure202as to fields and sub-fields that have changed and the timestamp field of data structure203will be updated with the timestamp of data structure202. However, if the “Other Players” field and sub-field of data structures202and203do not match, then the “Other Players” field and sub-fields of data structure202will be overwritten with the data from data structure203, because this mismatch would only occur if the status of other players had changed since the last synchronization event, in which case data structure203would contain the more recent data for the “Other Players.”

If the timestamp of data structure203indicates a later time than the timestamp in master game data structure400, then master game data structure400will be written over with the data from data structure203as to fields and sub-fields that have changed and its timestamp field will be updated with the timestamp of data structure203. However, if the “Other Players” field and sub-field of master game data structure400and data structure203do not match, then the “Other Players” field and sub-fields of data structure203will be overwritten with the data from master game data structure400, because this mismatch would only occur if the status of other players had changed since the last synchronization event, in which case master game data structure400would contain the more recent data for the “Other Players.”

This synchronization process between computing device130, server122, and server120has been described thus far with reference to changes in the status of User A. It will be understood by one of ordinary skill in the art that the same changes could occur in data structures301,302, and303and master game data structure400with reference to changes in the status of User B.

The changes in data structures as to User A will now propagate to the data structures associated with User B. Periodically, server120will compare the timestamp fields of master game data structure400and data structure303. If the timestamp of master game data structure400is a later time than that of data structure303, then data structure303will be written over with the data from master game data structure400as to “Other Players” field and sub-fields that have changed and the time stamp of data structure303will be updated with the time stamp of data structure400.

Periodically, server120will send a synchronization request to server124. The request will contain the timestamp from data structure303. If that timestamp indicates a later time than the timestamp in data structure302, then data structure302will be written over with the data from data structure303as to the “Other Players” field and sub-fields that have changed.

Periodically, server124will send a synchronization request to computing device140. The request will contain the timestamp from data structure303. If that timestamp indicates a later time than the timestamp in data structure302, then data structure302will be written over with the data from data structure303as to “Other Players” field and sub-fields that have changed.

Thus, it will be appreciated that User A and User B can engage in an interactive game through this synchronization process.

An embodiment enabling “airplane mode” will now be described. If User B loses connectivity to network100on computing device140(as might occur, for example, if computing device140is on an airplane or has lost WiFi or cellphone connectivity), then User B can continue to play the game on computing device140using local application145. Local application145will continue to update data structure301. When computing device140regains connectivity to network100, computing device140will initiate the synchronization process described above. In this manner, User A will learn of the changes in User B's status even though the changes had occurred while User B was not connected to network100.

The embodiments have been described as to two users, User A and User B, but it will be appreciated by one of ordinary skill in the art that the embodiments can accommodate any number of players. Similarly, the embodiments have been described as to two computing devices using two different platforms, computing device130and140, but it will be appreciated by one of ordinary skill in the art that the embodiments can accommodate any number of computing devices utilizing any number of different platforms.

In addition, while the foregoing has been with reference to particular embodiments of the invention, it will be appreciated by those skilled in the art that changes in these embodiments may be made without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims.