The other changes to the file are to implement n_loops and are not very interesting (or well coded for that matter ;P ) so I'll skip them.

Handling input

if( CL_Keyboard::get_keycode(CL_Keyboard::KEY_LEFT) )
{
  // do something intelligent here
}

   int x = CL_Mouse::get_x();
   bool pressed = CL_Mouse::left_pressed();

As I described in the previous chapter, ClanLib supports abstraction from these devices. Most games support configurable keys so an abstraction from the actual keys is wished. Let's look at an example from the ClanLib-examples module: input_devices.cpp.

// Abstract game input from physical input:
CL_InputButton_Group *fire_button = new CL_InputButton_Group;
CL_InputAxis_Group *hori_axis = new CL_InputAxis_Group;
CL_InputAxis_Group *vert_axis = new CL_InputAxis_Group;
 
</pre>

Here we create abstract devices for inputhandling. First, a 
fire_button
is created. In the rest of the game, if we want to know if the player wants to
fire, we'll use this object. As the name already suggests, the 
CL_InputButton_Group
 can handle a bunch of keys, al with the same 
purpose.

The same way we create a horizontal axis, and a vertical axis 
(
hori_axis
 and 
vert_axis
). 

Although mouse support is handled a different way, the mouse can also create a
CL_Axis object. This will be like the mouse-aiming in games as Quake. 

<pre>

// Add keyboard input:
fire_button->add(
        CL_Input::keyboards[0]->get_button(CL_Keyboard::KEY_ESCAPE));

fire_button->add(
        CL_Input::keyboards[0]->get_button(CL_Keyboard::KEY_SPACE));

</pre>

Here, we hook up the actual keys to the 
fire_button
. For each key
you want 
fire_key
 to react to, just call the 
add( CL_Key )
.
Now, for a keyboard, these 
CL_Key
's are easy to obtain. Just use
the 
get_button( <i>keyname</i> )
 function. 

hori_axis->add(
        new CL_InputButtonToAxis_Analog(
                CL_Input::keyboards[0]->get_button(CL_Keyboard::KEY_LEFT),
                CL_Input::keyboards[0]->get_button(CL_Keyboard::KEY_RIGHT)
                ));

vert_axis->add(
        new CL_InputButtonToAxis_Analog(
                CL_Input::keyboards[0]->get_button(CL_Keyboard::KEY_UP),
                CL_Input::keyboards[0]->get_button(CL_Keyboard::KEY_DOWN)
                ));


Analogue, we create the axis. For an axis, we need two keys ofcourse.

// Add joystick input (if available):
if (CL_Input::joysticks[0] != NULL)
{
        fire_button->add(CL_Input::joysticks[0]->get_button(0));
        fire_button->add(CL_Input::joysticks[0]->get_button(1));

        hori_axis->add(CL_Input::joysticks[0]->get_axis(0));
        vert_axis->add(CL_Input::joysticks[0]->get_axis(1));
}


Now, let's check if any joysticks are detected. 
If 
CL_Input::joysticks[0]==NULL
 then there aren't any joysticks.
If there isn't a first, there isn't any... Ah well. It's simple :).


If you want to use a mouse like this, try the following code:

        hori_axis->add(CL_Input::pointers[0]->get_axis(0));
        veri_axis->add(CL_Input::pointers[0]->get_axis(1));

        CL_InputButton *l_key = CL_Input::pointers[0]->get_button(0);
        CL_InputButton *r_key = CL_Input::pointers[0]->get_button(1);



<pre>
while (fire_button->is_pressed() == false)
{
...
}
</pre>

So, here we see how to check when one of the keys is pressed. Just use the
is_pressed()
 function. 

<pre>
int x = CL_Display::get_width()/2 +
  (int) (hori_axis->get_pos()*CL_Display::get_width()/2);

int y = CL_Display::get_height()/2 +
  (int) (vert_axis->get_pos()*CL_Display::get_height()/2);
</pre>

Let's see how one can read an axis. The 
get_pos()
 returns a
float between 0 and 1. So, multiply this with the height or width of the
field you're working in and you'll get the position. 


 Using network support 
This stuff isn't tested because I haven't got time for it yet.
It should work though because I ripped the examples from Magnus' network overview ;)



For network support, basically two classes are needed: 
CL_Network
,
for finding and creating a game, and 
CL_NetGame
 which represents
an actual network game, and thus handles all data.

As I described in the previous part,
there are two ways of communicating data.  First, I'll show how to set up
a network game. 
Second, I'll describe how you can write and 
read to NetChannels manually.
And as a third, I'll use the NetObject way. This is the easiest way
because most things are done for you. (And as such, the tutorial will be
shorter to write :P ). 

 Setting up a network game 

For a network game we need a server and clients. First, the server opens a game
on a certain port. 
CL_NetGame *netgame = CL_Network::create_game("MyGame", 5555);


The 
create_game( <i>name</i>, <i>port</i> ) 
 does exactly
this.  The name is the game_id. Each game should use a different
one so a Quakegame doesn't try to connect to ClanBomber. (Although that would 
be funny...)


 Joining a game is just as easy. If you already know the ip or
computername the game will be on, just use:  
 
CL_NetGame *netgame; 
CL_Network::find_game_at("MyGame", "my.server.net", 5555);  
if( CL_Network::peek_game_found() )
	try 
	{
  		netgame = CL_Network::receive_game_found(5000); 
	}
	catch (CL_Error err)
	{
		cout << "Join failed: " << err.message << endl;
	}
else
	cout << "No games found at " << "my.server.net";


The network game I am going to create is 
netgame
. First we
try to find a game with id 
MyGame
 at a server called
my.server.net
 at portnumber 
5555
. 
If you don't know the servername than you can use:
  CL_Network::find_games_broadcast("MyGame", 5555);


Both functions setup ClanLib to do some networking.  The
CL_Network::peek_game_found()
 returns true if any games are
found.  To actually get a CL_NetGame pointer, you need to call
CL_Network::receive_game_found(<i>timeout</i>)
. 
This will get you the first game found on the specified server (or servers
in the second case) or a NULL-pointer or exception if there weren't any
games or some other error occured. If you (or the gamer) aren't satisfied
with this one, just call 
 receive_game_found(<i>timeout</i>)
again and it'll give you the next one. If you have seen all games
available, and decided you actually wanted the first (*sigh*) than just
call 
CL_Network::clear_games_found()
 and you can start all
over again.

 Reading and writing to NetChannels 

Data is transferred as a CL_(Out/In)putSource_Memory object. If you write or
read to a NetChannel you must use this class. In it, you can store whatever
you want, see the documentation of the CL_InputSource en CL_OutputSource classes
how these work. (Or read the tutorial about these common classes when I come
around to those). 

You probably want to build a function that checks if the netgame has any data
for you. Remember that it should be called in time, or you'll get a queue of
messages waiting for you, and your game will fall behind.

To find out if the server has any data waiting, use:
if (netgame->peek(channel_nr)) 
{
  ... // read the data from the netgame here
}


Here, 
netgame
 is the CL_NetGame pointer to the networkgame
you joined.  Remember, we are working on the client side. The 
channel_nr
is the number of the NetChannel you want to read from. 

Now, actually read the data:
CL_InputSource_Memory updates = netgame->receive(channel_nr);


As I said before, all data is written and read using CL_(In/Out)putSource_Memory.
A brief example how to extract data from the CL_InputSource_Memory class:

int n_monsters = updates.read_int32();
for( int i=0; i<n_monsters; i++ )
  {
  monster[i].x = updates.read_int32();
  monster[i].y = updates.read_int32();
  }


Now, let's see how to write to a channel. 
You can send a message to the server, to a specific computer, or to a group of
computers. I'll explain later how to create a group of computers.

First, we create a datablock to send:
CL_OutputSource_Memory msg;
msg.write_float32( myself.manapoints);
msg.write_float32( myself.hitpoints );


And now, we send the data to the server:
netgame->send( channel_nr, netgame->server, msg);


The first and the last argument should be clear. These are the NetChannel
to which the message is sent, and the message itself. The second might
need some explaining. ClanLib has an easy way of creating NetGroups, a group
of computers (for example: in a team). The second argument is the group
you wish to send to. In this case this is the server and we get the 
server's NetGroup using the pointer 
server
 in the netgame object.

 Using NetObjects 

If you have a rather complicated game, you probably don't want each
network-aware to keep track of the networktraffic. An object should not be aware
when it's data is send or received. For this, ClanLib has created the CL_NetObject
class. This class has two abstract functions (
virtual void serialize_load(CL_InputSource *input)=0;
 and
virtual void serialize_save(CL_OutputSource *output)=0;
)
which you have to inherit to create the data-packages. Tha's all you need for a
network aware object. When the actual data is sent through the network is not
decided by the object, but by the game (or perhaps a CL_NetObjectController).
Another advantage is that there is no distinction if the object is controlled
local or on another computer.


An example:
class Monster: public CL_NetObject
{
  private:
    int x,y,hp;

  public:
    virtual void serialize_load(CL_InputSource *input)
    {
      x = input->read_int32();      
      y = input->read_int32();      
      hp = input->read_int32();      
    }
    virtual void serialize_save(CL_OutputSource *output)
    {
      output->write_int32(x);      
      output->write_int32(y);      
      output->write_int32(hp);      
    }
};


If you have very simple objects which has a constant amount of variables
(like only coordinates and hitpoints) it is easier to use a derived class
of CL_NetObject called CL_NetObject_Simple. This class has already
inherited the serialize functions for you. Now you only have to indicate
which variables you wish to be communicated and you're ready to go. This
can be done in the constructor using the supplied add_xxx() functions.

class Monster: public CL_NetObject_Simple
{
  private:
    int x,y,hp;

  public:
    Monster() 
    {
      add_int32( &x );
      add_int32( &y );
      add_int32( &hp );
    }
};


Now, when does the actual data get sent? The NetObjects won't know. They 
don't need to know. ClanLib supplies a CL_NetObjectController which does 
most of the work. To this class you can 
add()
 a NetObject.
The CL_NetObjectController automatically creates a mirror-NetObject on every 
client so each participating computer can see it. Furthermore, you only have to
call the 
update(<i>game</i>,<i>channel_nr</i>)
 and everything else
is handled for you.

Erhm... Some code here would be nice :) Problem is,
I don't know yet how to get a list of all CL_NetObjects...
Will find out soon, just be patient.