ASSS Wiki - User contributions [en]

PHP ping client

2007-12-26T13:16:26Z

Goldeye: Added category:utilities

Version 1.0 of this PHP class was produced by Goldeye on 12/26/07. It provides functions to report on the number of players logged on -- as well as the number playing -- in an ASSS zone or specific arenas.
It is currently only compatible with ASSS's new [[Ping_Protocol]].
It's intended function is to put this information on a zone's website.

The code at the top is demonstration using SSCE and it's two most active arenas. It can be removed without affecting the class.
Basic PHP knowledge is required to adapt the script

Feel free to contact the author with any requests or bugs with the script.

<code><pre>
<?php
//ServerPopulation.php v1.0
// by Goldeye 12/26/07
// Goldeye.Ichiban@gmail.com

//Errors are silent and the recv times out default 100ms.
//Updates occur no more than once in 60 sec by default anyway.
$hz = new ServerPopulation("67.19.122.82",7502);
$total = $hz->get_server_total();
$playing = $hz->get_server_playing();
$spec = $total-$playing;
$pub0=$hz->get_arena("0");
$fb=$hz->get_arena("football");
//Note: name automatically lowercased before it gets here.
print "Total: $playing playing, $spec spectating, $total logged in.\n";
print "(Public 0): $pub0[playing] playing, $pub0[spec] spectating, $pub0[total] logged in.\n";
print "Football: $fb[playing] playing, $fb[spec] spectating, $fb[total] logged in.\n";

class ServerPopulation
{
var $host;
var $port;
var $last_time;
var $update_time;
var $timeout;
var $arenas = array();
var $total;
var $playing;

function ServerPopulation($host,$port,$update_time=60,$timeout=100)
{ //For PHP4
$this->__construct($host,$port,$update_time,$timeout);
}

function __construct($host,$port,$update_time=60,$timeout=100)
{ //For PHP5
$this->host = $host;
$this->port = $port;
$this->update_time=$update_time;
$this->timeout=$timeout*1000;
$this->update();
}

function get_server_total()
{
return $this->total;
}

function get_server_playing()
{
return $this->playing;
}

function get_arena($name)
{
return $this->arenas[$name];
}

function get_arena_array()
{
return $this->arenas;
}

function update()
{
if(time()-$this->last_time < $this->update_time)
return;

$socket = socket_create(AF_INET, SOCK_DGRAM, 0);
$rcvtimeo["sec"]=0;
$rcvtimeo["usec"]=$this->timeout;
socket_set_option($socket,SOL_SOCKET,SO_RCVTIMEO,$rcvtimeo);
$result = socket_connect($socket,$this->host,$this->port);
if(!$socket || !$result) return;
$out=pack("VV",0,0x01|0x02);
socket_write($socket, $out, 8);
if(@socket_recv($socket,&$in,512,0) < 1)
return;
$res = unpack("Vtime/Voptions",$in);
$opt = $res["options"];
if($opt & 0x01) // Server info included.
{
$in = substr($in,8);
$res = unpack( "Vtotal/Vplaying",$in);
$this->total = $res["total"];
$this->playing = $res["playing"];
}
if($opt & 0x02) // Arena info included.
{
$in = substr($in,8);
do
{
$n = strpos($in,0x00);
$name = strtolower(substr($in,0,$n));
$in = substr($in,$n+1);
$res = unpack("vtotal/vplaying",$in);
$res["spec"]=$res["total"]-$res["playing"];
$in = substr($in,4);
$this->arenas[$name]=$res;
}
while(strlen($in)>1);
}
$this->last_time=time();
}
}
?></pre></code>
[[Category:Utilities]]

PHP ping client

2007-12-26T13:14:06Z

Goldeye: Initial -- pasted the code

Ping Protocol

2007-12-26T13:03:00Z

Goldeye: Added link to PHP_ping_client

There are two ping protocols currently in use. The old ping protocol, supported by [[ASSS]], [[Subgame]], [[Continuum]], and [[Directory server]]s, allows one to receive information about the number of players in a [[zone]]. The new ping protocol, supported by ASSS, can be used to retrieve specific information on the distribution of the players in each [[arena]] within a zone.

A PHP class to use the new ping protocol to obtain a zone's information is available at [[PHP_ping_client]].

The following is from doc/ping.txt which you can find inside the ASSS distro.

However, the latest version can always be found at http://www.sscx.net/asss/ping.txt

<pre>
ping/information protocol
version 1.0
grelminar@yahoo.com

-------------------------

all communication happens over udp on the port one higher than the game
protocol port. byte order is little-endian. no packet will be larger
than 512 bytes. everything is stateless.

option one (the old ping protocol):

client sends a 4 byte packet to the server's ping port. typically the 4
bytes will be a timestamp, but the server doesn't interpret them.

struct C2SSimplePing {
u32 timestamp;
};

the server replies with 8 bytes:

struct S2CSimplePing {
u32 total;
u32 timestamp;
};

where total is the current number of fully-connected clients (including
bots but not including server-internal fake players). timestamp is a
copy of the client's timestamp.

for asss virtual zones, the total will be the number of fully-connected
clients in all the arenas belonging to that virtual zone.

option two (new asss ping protocol):

client sends an 8 byte packet to the server's ping port.

struct C2SNewPing {
u32 timestamp;
u32 options;
};

again, the timestamp isn't interpreted by the server.

options is a bitfield where each bit indicates a request for a certain
type of information to be returned.

the current defined bits are:

PING_GLOBAL_SUMMARY = 0x01 - global player count information
PING_ARENA_SUMMARY = 0x02 - by-arena player count information

the server responds with a variable-length packet.

the first 8 bytes are always the following:

struct S2CNewPingHeader {
u32 timestamp;
u32 options;
};

the timestamp is copied from the client. the options bitfield indicates
what data is present, and how the following bytes should be interpreted.

note that the options returned might not be the same as the options
requested, although typically they will be.

if PING_GLOBAL_SUMMARY is included, the next 8 bytes will be:

struct S2CNewPingGlobalSummary {
u32 total;
u32 playing;
};

where total is the number of fully-connected clients, and playing is the
number of clients that are actually flying around in ships.

if PING_ARENA_SUMMARY is included, the next variable-length sequence of
bytes will be a series of blocks of this format:

struct S2CNewPingArenaSummaryChunk {
char name[]; // variable-length and null-terminated
u16 total;
u16 playing;
};

arena names that consist of only digits are considered "public arenas"
and should probably be displayed as "(Public %d)".

a one-byte chunk with a zero-length name (that is, a single nul byte)
indicates the end of the series.

note that the sums of the data in the arena chunks may not add up to the
values in the global summary because of the presence of hidden arenas.
</pre>

[[Category: Protocol]]