I'm presently creating a real-time multiplayer game, and also have been evaluating various cloud-based hosting solutions. I'm unsure whether Application Engine fits me, and would appreciate any feedback.

Essentially, I would like the machine to operate such as this: Player A computes round n, and creates a hash from the overall game condition in the finish of this round. Then he transmits his instructions for your round, and also the hash, like a http Publish towards the server. Player B does exactly the same factor, in parallel.

The server, while handling the Publish from the player, first creates the received hash code towards the memcache. When the hash in the other player is not within the memcache, it waits and periodically inspections the memcache for that other gamers hash. The moment both hashes have been in the memcache, it compares them for equality. If they're equal, the server transmits the instructions of every player towards the correspondingly other one because the http response.

A round like this should last around half another, meaning two demands per player per second.

Obviously, by doing this to do it'll only work if you will find a minimum of two cases of the applying running, as two demands should be worked within parallel. Also, the memory cache should be consistent total instances, be fairly reliable, increase immediately.

I am unable to use XMPP because I would like my game to have the ability to run within restricted systems, therefore it needs to be restricted to http on port 80.

It is possible to method to enforce that two cases of the application will always be running? Exist glaringly apparent defects during my design? Do you consider an architecture such as this might focus on Application Engine? Otherwise, what cloud based solution can you suggest?

In my opinion this might work. The important thing API that you should find out about / test would most likely function as the Funnel API. That's an amount allow backwards and forwards communication between your client and server.

The following problem to bother with could be memcache. Generally, it's reliable, however in the most stringent sense we are meant to think that memcached data could disappear anytime.

If you choose that you cannot risk losing the information like this, you will want to persist it within the datastore, meaning you'll have to experiment to make certain you are able to sustain 2 moves per turn. I believe you could do, although not trivially so. Should you have had stated 1 move every 3 seconds I'd say "not a problem.Inch But multiple updates to 1 entity per second begin to bump facing the practical limit on creates per second, especially if they're transactional.

Getting multiple instances running won't be an issue - you are able to pay to help keep instances warm if required.