One of the interesting and usefull feature in SmartFoxServer
Lite is the ability to send and receive complex data
structures (arrays, objects ...) very easily and transparently.
In this article we'll show you how this feature can really speed
up the process of creating complex multiuser applications and games.
[ DATA STRUCTURES ]
In the previous tutorial we concentrated our attention on the "User
Variables" and we've learnt how to use them.
"User variables" are very usefull when you want to store
settings for each client connected and have all the other users
receive notices about changes in those values.
There are cases in which this approach is not the best one, for
example in a turn-based game.
Classic turn based games can be board games (chess, connect 4 ...),
role play games, card games, strategy games etc...
Every time a user makes a move in a "connect 4" game
or in a "chess" game we don't really need to store that
move as a "User Variable". We would just need to be able
to send the move data to the other clients, without storing it anywhere.
One more example can be a multiuser whiteboard application: anytime
someone draws something on it we should just send the information
about the lines and curves that were drawn in a convenient format
and again no need to save that data.
The sendObject() method of the SmartFoxClient
API allows us to do this very easily, check this example:
- move =
That's all :-)
The other clients will receive an onObjectReceived
- smartfox.onObjectReceived = function(obj, user)
- // do something cool here
where obj is the object received and "user"
is the User object of the sender.
The following list represents the type of variables that can be
sent through the sendObject() method:
All the other variable types are ignored.
To give you an example that is a little more complex, imagine you're
playing an rpg game and you have to send some data
about you character:
- myChar =
"short sword", "long
sword", "hammer", "shield")
As you can see you can nest other objects and arrays and create
pretty complex data structures.
In the next tutorial we'll use this feature to implement our first
simple multiplayer game.
[ WHAT'S BEHIND ]
It is not the purpose of this tutorial to show how this mechanism
works, however I'd like to discuss the basics of it in order to
better understand what's going on and how to get the best out of
The process of sending and receiving structured Actionscript objects
is done through a serialization/deserialization mechanism.
To tell it in simple words your AS object is transformed in a more
convenient format (xml in our case) and sent to the server which
in turn will transmit the received data to the other users. As soon
as the client API receives the serialized data it will re-construct
the object and make it available to the application.
It's always important to take care of the amount of data that you're
sending and receiving. The more complex and nested is the structure
of your objects the more time it will take to send it through the
network and if you exceed with informations your application may
not respond as expected.
If your application/game is targeted to broadband users then this
should not be much of an issue, however slower modem connections
have limited bandwidth (4 to 7 KB/s) and you will also have to deal
with the inevitable lag of internet connections.
Also if you waste bandwidth by sending unnecessary data you will
steal bandwidth to other users connected to the server and if you
saturate it the general performance of the clients connected will
The previous rpg game example should not give problems to slower
modem connections, however it can be optimized efficiently by
replacing those strings in the inventory array with numeric ids.
- myChar =
where 1,2,3,4,5 represent the various inventory items.
You can save about 30 bytes by using this new object. Doesn't sound
like it's so much ?
Well think about having 100 connected users and you're saving 3KB/s
(24Kb/s) of bandwith and if the users were 1000 you
would be saving 240kb/s ... that's almost half of a DSL connection,
not that bad! :-)
Now that we have seen the theory behind sending and receiving Actionscript
data through the SmartFoxServer it's time to put
this new knowledge to work in a real world example.
In the next tutorial you will find a complete simple game of Tic-Tac-Toe.
Have fun! :-)