GameDesign: Difference between revisions

So let's define the reply to each message. Before explaining how to process eahc message, let's clarify that the best way of modelling this system is using finite automates, (finite state machine) where, based on the input, we change the state we are currently in and produce an output.

and a we have created a PlayerEntry for this player with an unique correct clientid.

= Basic idea behind Database storage =

==Database Tables and Relationships ==

The database table relationship schema is:

<pre>

Table PLAYER

{

PK(username)

password

}

Table CHARACTERS

{

PK(character)

content

}

Table LOGIN_EVENT

{

PK(id)

address

timedate

result

}

Table STATISTICS

(

PK(timedate)

bytes_send

bytes_recv

players_login

players_logout

players_timeout

players_online

)

Table RPOBJECT

(

PK(id)

slot_id

)

Table RPATTRIBUTE

(

PK(object_id)

PK(name)

value

)

Table RPSLOT

(

object_id

name

PK(slot_id)

)

</pre>

Relationships:

<pre>

Relationship PLAYER_CHARACTERS

{

PK(player_username)

PK(characters_character)

}

Relationship PLAYER_LOGIN_EVENT

{

PK(player_username)

PK(login_event_id)

}

</pre>

Translate this to SQL easily and you have the SQL schema of Marauroa

== JDBC Database HOWTO==

JDBC technology is an API that lets you access virtually any tabular data source from the Java programming language. It provides cross-DBMS connectivity to a wide range of SQL databases, and now, with the new JDBC API, it also provides access to other tabular data sources, such as spreadsheets or flat files.

JDBCPlayerDatabase is anyway not database independent; on the Player table we are using AUTOINCREMENT that is a unique keyword of MySQL that is not part of the SQL standard.

You need to download MySQL Connector/J in order to get it to run. <br>

http://www.mysql.com/downloads/api-jdbc-stable.html

To configure Marauroa to work with a JDBC source we need to modify the configuration of the JDBC Connection.

So open the configuration file marauroad.ini ''(or any other)'' and edit the next fields

<pre>

marauroa_DATABASE=JDBCPlayerDatabase

jdbc_class=com.mysql.jdbc.Driver

jdbc_url=jdbc:mysql://localhost/marauroa

jdbc_user=marauroa_dbuser

jdbc_pwd=marauroa_dbpwd

</pre>

jdbc_class is the field that says what Driver to use. Please refer to your software manual to see the multiple options.

jdbc_url points to the type and source of the information, for MySQL the string must be as follow:

jdbc:mysql://ip:database_name/

jdbc_user is the username for the database and jdbc_pwd is the password for that username in the database.

Then simply save the changes and ready.

Before using the application with the database, you need to create the database itself. So in case of MySQL just open MySQL and write:

<pre>

create database marauroa;

grant all on marauroa.* to marauroa_dbuser@localhost identified by 'marauroa_dbpwd';

</pre>

The rest of code is handled by the server itself, and will create the tables if they don't exits.

PlayerContainer is the data structure that contains all of the needed info about the players to keep the game running.

It consists of a list of RuntimePlayerEntry objects, and is heavily linked with the PlayerDatabase, so we can hide the complexity to GameManager. By making PlayerDatabase hidden by PlayerContainer we achieve the illusion that managing the runtime behavior we modify automatically the permanent one.

RuntimePlayerEntry is the structure that contains the information of the player while it is online. <br>RuntimePlayerEntry contains:

* clientid<br>

Clientid is the field in charge of indexing players in the server. See the document about clientid generation to understand what they are and how they are generated.

* source<br>

Source is the IPv4 address of the client, so that we can determine if the message is really coming from client or another person trying to impersonate it.

* timestamp<br>

Timestamp is used to determine if a client has timed out and as such, it is only wasting resources on the server. As you know, UDP is not a delivery-guaranteed protocol, so we need to check ourselves for dead clients. Take care that it only indicates that the player timed out, it doesn't apply any kind of measures over them.

* storedTimestamp<br>

storeTimestamp is used to determine when it was the last time that this player was stored on database, as storing for each change will be very CPU consuming so we cached it and store each 5 minutes.

* username<br>

Username is filled in at runtime with a Login event so that we are able to use the database from PlayerContainer, This way by knowing the clientid we can also know the username.

* choosenCharacter<br>

choosenCharacter is filled in at runtime with a ChooseCharacter event so that we are able to use the database from PlayerContainer, This way by knowing the clientid we can also know the choosenCharacter.

* state<br>

**Have to login

**Login Complete

**Game begin

**Logout

When we create the entry it is by default Have to login. Once you have logged in correctly, we change state to Login Complete, and once you have chosen a Character we change it to game begin. The logout state is trivial :)

The main idea is that some operations are only allowed in one state, so we can more easily control it with the state property.

Perception counter is used for having a incremental counter of the perceptions send, so that client can see if it gets out of sync.

Perception previous RPObject is the RPObject that was sent on the last perception, so we can track * changes on our RPObject without disturbing the rest of the system.

This flag indicates if the player notified us that it was out of sync, so we can re sync it as soon as possible.

As you can see all we need to operate PlayerDatabase is a username and choosenCharacter. So using PlayerEntryContainer we can fully operate it.

Each client MUST have a session id to avoid another player to impersonate it. sessionid must be a short or int to make harder for an attacker to guess it.

To make it really fun, clientids are generated randomly for each player with the unique condition that two different players MUST have two different clientids.

Home

Why bother with it? Well, imagine that a player logs out when the perception is being built, it will no longer be accessible for the RP Manager, when it really expects the object to be there. Or a removed player that is removed too by RP Manager. That is a really serious problem, as it will make the server fail.

So we need to synchronize game and RP manager.

The idea is that they request to a central mutex access to the PlayerEntryContainer, and that mutex is the one that decide how the access is done.

We need to differentiate between the two types of accesses, read access and write access. We can have without problems two readers accessing in parallel, but we can only have one write at the same time modifying the stuff.

Whatever action we choose in GameManager they are Write actions, as the modify the state of the PlayerContainer, but in RP we have two parts, one that build the perceptions that is read only and one that removes idle players that is write, so we must apply two different locks there.

=Actions and Objects=

The whole Marauroa system is managed by two main entities, RPAction and RPObject

==Actions==

To express the willing of a client to do something it must send the server a MessageC2SAction message.

An action is composed of several attributes, an attributed is similar to a variable that has a name and contains a value.

There are optional and mandatory attributes. If a mandatory attribute is not found, the message is skipped by the RPServerManager.

Mandatory Actions Attributes are action_id and type.

The action_id is used to identify the action when a resulting response comes in a perception

Optional Actions Attributes: (Read "Actions Explained" for more details.)

==Objects==

The containers of information of the whole Marauroa server are RPObjects. An object is composed of several attributes, an attribute is similar to a variable that has a name and contains a value and also it is composed of Slots. A Slot is a container or array of containers that the object has to host other objects inside it.

Mandatory Object Attributes: id, type and zoneid

id is an unique identification for the Object and zoneid is the identification for the zone where the object resides and type is the type of the object aka class, so that you can share attributes for all the instances of the class.

An id is only unique inside the zone which contains that object.

Also engine give special treatment to two types of attributes:

- Attributes that begin with ! are completely hidden for all the users but the owner of the object.

- Attributes that begin with # are completely hidden for all the users.

===Slots===

As you know Objects can contain inside another object much like you have the keys inside your pocket. The goal of Slots is to provide a richer game play while reducing the number of object in the zone.

To have these objects inside, we need our hoster object to have slots to place them. One slot can only handle one single object.

For example a avatar can have:

- left hand

- right hand

- backpack

- left pocket

- right pocket

and we can store objects on these slots.

Once the object is stored inside the avatar or another object, the only way of accessing it is through the object that contains our stored object.

= How Perceptions and Actions work =

Actions are sent from client to server in order to make their character to do an action. In order for the client to know the result of the action Server need to send it to client. How?

On a first try, we used to send client back an action that was the result, but make code really hard because we had to update to different things, perceptions and actions, so the idea appeared intuitively: Why not join action reply and perceptions.

So the action reply is stored inside each object (that executed the action ) with a set of attributes that determine the action return status and the attributes. This way of working make a bit harder to RPManager but it simplify a lot the creation of new clients.

See Actions reply in Objects document to know exactly what is returned, but keep in mind that it depends of each particular game.

=RPManager=

The goal of RP Manager is to handle the whole RP game. This means mainly:

* run RPActions from clients

* manage RPWorld

* control triggers for events

* control AI

As you see this is a HUGE class that is complex. So the idea is to split this behavior into smaller subclasses.

RPManager provides a simple interface to the GameManager for using it:

* addRPAction

* addRPObject

* removeRPObject

* hasRPObject

addRPAction simply queues an action for that player to be executed on the next turn.

addRPObject, removeRPObject and hasRPObject is a interface to manage RPWorld.

The main outline of RPManager could be:

<pre>

forever

{

Procced through every action in this turn

Build Perception

Remove timed out players

Wait for Turn completion.

Go to Next Turn

}

</pre>

RPScheduler is the class that handles actions to be queued for each player. All the complexity of Action management should be handled here.

RuleProcessor is a wrapper class for hide actions code. All the actions code MUST be here, this class also acts as a Action code loader, as some actions are not part of Marauroa, but scripts.

=Delta perception Algorithm=

The main idea behind the DPA is not to send ALL the objects to client, but only those that has been modified.

Imagine that we have 1000 objects, and only O1 and O505 are active objects that are modified each turn. Ok?

Traditional method:

<pre>

- Get objects that our player should see ( 1000 objects )

- Send them to player ( 1000 objects )

- Next turn

- Get objects that our player should see ( 1000 objects )

- Send them to player

- Next turn

...

</pre>

I hope you see the problem..., we are sending again objects that never changed.

The delta perception algorithm:

<pre>

- Get objects that our player should see ( 1000 objects )

- Reduce the list to the modified ones ( 1000 objects )

- Store also the objects that are not longer visible ( 0 objects )

- Send them to player ( 1000 objects )

- Next turn

- Get objects that our player should see ( 1000 objects )

- Reduce the list to the modified ones ( 2 objects )

- Store also the objects that are not longer visible ( 0 objects )

- Send them to player ( 2 objects )

- Next turn

...

</pre>

The next step on delta perception algorithm is pretty clear: delta^2 The idea is to send only what changes of the objects that changed. That why you save even more bandwidth, making perceptions around 20% of the delta perception size.

The delta^2 algorithm is based on four containers:

* List of added objects

* List of modified added attributes of objects

* List of modified deleted attributes of objects

* List of deleted objects

An area really related to DPA is RPZone

Well, as you should know, MPEG adds a full frame each X number of frames, so it can be used as synchronization in case the file get corrupted. The idea is that if you fail to continue decompressing data, you can always omit things until the next full frame and then when you synced. The idea here is similar, if we fail to synchronize with server we send him a Out of Sync Message so that server will send a sync perception so that clients can synchronize, as UDP is not a secure transport.

To make perception works it is important to call the modify method on RPZone so this way objects modified are stored in the modified list.

=Zones and Worlds=

Objects must be stored somewhere, and we use Zones now to store them. A zone is just a container of Objects.

In order to improve the modifiability of the Marauroa platform we have made RPZone to be an interface so that if you want you can implement it as you think it is more efficient.

The actual Marauroa RP Zone consists of several data structures:

* a HashMap of RPObject.ID to RPObject

* a List of RPObject

* a Perception

The idea is to have already computed in the Zone the perception so saving LOTS of time that would be needed to generate it. All the data structures contain the same objects, but the hashmap is used to fast search of objects using its RPObject.ID, this is the most usual way for locating the object. List is used to improve the time required to build a total perception. And well, we used perception to pre-calculate the delta perception.

Actually the perception is the same for all the players on the Zone.

In order to make perceptions work, you have to manually call modify method so that you notify the zone about changes in a character.

==Classes of Objects Explained==

Classes of Objects are the basic way of structuring Marauroa data structures.

A class defines types of the attributes and its visibility and gives it an internal code that is used to speed up searchs and save bandwidth. You can base a class on another, this feature is known as inheritance.

The data types available are:

* Strings

* Short strings ( up to 255 bytes )

* Integers ( 4 bytes )

* Shorts ( 2 bytes )

* Byte ( 1 byte )

* Flag ( it is a binary attribute )

Attributes can also be visible if clients see them when they change, or invisible if clients can't see them.