/**
* Specific player parse for The Ship
*
* Player response has unknown data after the last real player
*
* @param \GameQ\Buffer $buffer
*
* @return array
*/
protected function processPlayers(Buffer $buffer)
{
// Set the result to a new result instance
$result = new Result();
// We need to read the number of players because this response has other data at the end usually
$num_players = $buffer->readInt8();
// Player count
$result->add('num_players', $num_players);
// No players, no work
if ($num_players == 0) {
return $result->fetch();
}
// Players list
for ($player = 0; $player < $num_players; $player++) {
$result->addPlayer('id', $buffer->readInt8());
$result->addPlayer('name', $buffer->readString());
$result->addPlayer('score', $buffer->readInt32Signed());
$result->addPlayer('time', $buffer->readFloat32());
}
// Extra data
if ($buffer->getLength() > 0) {
for ($player = 0; $player < $num_players; $player++) {
$result->addPlayer('deaths', $buffer->readInt32Signed());
$result->addPlayer('money', $buffer->readInt32Signed());
}
}
unset($buffer);
return $result->fetch();
}
/**
* Handle player info, different than quake3 base
*
* @param Buffer $buffer
*
* @return array
* @throws \GameQ\Exception\Protocol
*/
protected function processPlayers(Buffer $buffer)
{
// Set the result to a new result instance
$result = new Result();
// Loop until we are out of data
while ($buffer->getLength()) {
// Make a new buffer with this block
$playerInfo = new Buffer($buffer->readString("\n"));
// Add player info
$result->addPlayer('frags', $playerInfo->readString(" "));
$result->addPlayer('ping', $playerInfo->readString(" "));
// Skip first "
$playerInfo->skip(1);
// Add player name, encoded
$result->addPlayer('name', utf8_encode(trim($playerInfo->readString('"'))));
// Skip space
$playerInfo->skip(1);
// Add team
$result->addPlayer('team', $playerInfo->read());
// Clear
unset($playerInfo);
}
// Clear
unset($buffer);
return $result->fetch();
}
/**
* Process the user listing
*
* @param string $data
* @param \GameQ\Result $result
*/
protected function processPlayers($data, Result &$result)
{
// We need to split the data at the pipe
$players = explode('|', $data);
// Iterate over the channels
foreach ($players as $player) {
// Offload the parsing for these values
$properties = $this->processProperties($player);
// Iterate over the properties
foreach ($properties as $key => $value) {
$result->addPlayer($key, $value);
}
}
unset($data, $player, $players, $properties, $key, $value);
}
/**
* Handles processing the the channels and user info
*
* @param array $data
* @param \GameQ\Result $result
*/
protected function processChannelsAndUsers(array $data, Result &$result)
{
// Let's add all of the channel information
foreach ($data as $key => $value) {
// We will handle these later
if (in_array($key, ['channels', 'users'])) {
// skip
continue;
}
// Add the channel property as a team
$result->addTeam($key, $value);
}
// Itereate over the users in this channel
foreach ($data['users'] as $user) {
foreach ($user as $key => $value) {
$result->addPlayer($key, $value);
}
}
// Offload more channels to parse
foreach ($data['channels'] as $channel) {
$this->processChannelsAndUsers($channel, $result);
}
}
/**
* Handles processing the player data into a usable format
*
* @param Buffer $buffer
*
* @return array
*/
protected function processPlayers(Buffer $buffer)
{
// Set the result to a new result instance
$result = new Result();
// Get the number of players
$result->add('numplayers', $buffer->readInt16());
// Parse players
while ($buffer->getLength()) {
// Player id
if (($id = $buffer->readInt16()) !== 0) {
// Add the results
$result->addPlayer('id', $id);
$result->addPlayer('name', utf8_encode($buffer->readPascalString()));
}
}
unset($buffer, $id);
return $result->fetch();
}
/**
* Handles processing the player and team data into a usable format
*
* @param \GameQ\Buffer $buffer
* @param \GameQ\Result $result
*/
protected function processPlayersAndTeams(Buffer &$buffer, Result &$result)
{
/*
* Explode the data into groups. First is player, next is team (item_t)
* Each group should be as follows:
*
* [0] => item_
* [1] => information for item_
* ...
*/
$data = explode("", $buffer->getBuffer());
// By default item_group is blank, this will be set for each loop thru the data
$item_group = '';
// By default the item_type is blank, this will be set on each loop
$item_type = '';
// Loop through all of the $data for information and pull it out into the result
for ($x = 0; $x < count($data) - 1; $x++) {
// Pull out the item
$item = $data[$x];
// If this is an empty item, move on
if ($item == '' || $item == "") {
continue;
}
/*
* Left as reference:
*
* Each block of player_ and team_t have preceding junk chars
*
* player_ is actually \x01player_
* team_t is actually \x00\x02team_t
*
* Probably a by-product of the change to exploding the data from the original.
*
* For now we just strip out these characters
*/
// Check to see if $item has a _ at the end, this is player info
if (substr($item, -1) == '_') {
// Set the item group
$item_group = 'players';
// Set the item type, rip off any trailing stuff and bad chars
$item_type = rtrim(str_replace("", '', $item), '_');
} elseif (substr($item, -2) == '_t') {
// Check to see if $item has a _t at the end, this is team info
// Set the item group
$item_group = 'teams';
// Set the item type, rip off any trailing stuff and bad chars
$item_type = rtrim(str_replace(["", ""], '', $item), '_t');
} else {
// We can assume it is data belonging to a previously defined item
// Make a temp buffer so we have easier access to the data
$buf_temp = new Buffer($item, Buffer::NUMBER_TYPE_BIGENDIAN);
// Get the values
while ($buf_temp->getLength()) {
// No value so break the loop, end of string
if (($val = $buf_temp->readString()) === '') {
break;
}
// Add the value to the proper item in the correct group
$result->addSub($item_group, $item_type, utf8_encode(trim($val)));
}
// Unset our buffer
unset($buf_temp);
}
}
// Free up some memory
unset($data, $item, $item_group, $item_type, $val);
}
/**
* Process the players
*
* @param \GameQ\Buffer $buffer
*
* @return array
*/
protected function processPlayers(Buffer $buffer)
{
// Decode into items
$items = $this->decode($buffer);
// Set the result to a new result instance
$result = new Result();
// Number of data points per player
$numTags = $items[1];
// Grab the tags for each player
$tags = array_slice($items, 2, $numTags);
// Get the player count
$playerCount = $items[$numTags + 2];
// Iterate over the index until we run out of players
for ($i = 0, $x = $numTags + 3; $i < $playerCount; $i++, $x += $numTags) {
// Loop over the player tags and extract the info for that tag
foreach ($tags as $index => $tag) {
$result->addPlayer($tag, $items[$x + $index]);
}
}
return $result->fetch();
}
/**
* Handles processing the rules data into a usable format
*
* @param \GameQ\Buffer $buffer
*
* @return array
*/
protected function processRules(Buffer $buffer)
{
// Set the result to a new result instance
$result = new Result();
// Number of rules
$result->add('num_rules', $buffer->readInt16());
// Run until we run out of buffer
while ($buffer->getLength()) {
$result->add($buffer->readPascalString(), $buffer->readPascalString());
}
unset($buffer);
return $result->fetch();
}
/**
* Handles processing the rules data into a usable format
*
* @param \GameQ\Buffer $buffer
*
* @return mixed
*/
protected function processRules(Buffer $buffer)
{
// Set the result to a new result instance
$result = new Result();
// Count the number of rules
$num_rules = $buffer->readInt16Signed();
// Add the count of the number of rules this server has
$result->add('num_rules', $num_rules);
// Rules
while ($buffer->getLength()) {
$result->add($buffer->readString(), $buffer->readString());
}
unset($buffer);
return $result->fetch();
}
/**
* Process the user listing
*
* @param string $data
* @param \GameQ\Result $result
*/
protected function processPlayers($data, Result &$result)
{
// Create a buffer
$buffer = new Buffer($data);
// The first line holds the column names, data returned is in column/row format
$columns = explode("\t", trim($buffer->readString("\n")), 16);
// Loop through the rows until we run out of information
while ($buffer->getLength()) {
// Grab the row, which is a tabbed list of items
$row = trim($buffer->readString("\n"));
// Explode and merge the data with the columns, then parse
$data = array_combine($columns, explode("\t", $row, 16));
foreach ($data as $key => $value) {
// Now add the data to the result
$result->addPlayer($key, utf8_encode($value));
}
}
unset($data, $buffer, $row, $columns, $key, $value);
}
/**
* Handles processing the player and team data into a usable format
*
* @param \GameQ\Buffer $buffer
* @param \GameQ\Result $result
*/
protected function processPlayersAndTeams(Buffer &$buffer, Result &$result)
{
// Players and team info
while ($buffer->getLength()) {
// Get the flags
$flags = $buffer->readInt8();
// Get data according to the flags
if ($flags & 1) {
$result->addPlayer('name', $buffer->readPascalString(1, true));
}
if ($flags & 2) {
$result->addPlayer('team', $buffer->readPascalString(1, true));
}
if ($flags & 4) {
$result->addPlayer('skin', $buffer->readPascalString(1, true));
}
if ($flags & 8) {
$result->addPlayer('score', $buffer->readPascalString(1, true));
}
if ($flags & 16) {
$result->addPlayer('ping', $buffer->readPascalString(1, true));
}
if ($flags & 32) {
$result->addPlayer('time', $buffer->readPascalString(1, true));
}
}
}
/**
* Handle processing details since they are different than BF3
*
* @param \GameQ\Buffer $buffer
*
* @return array
*/
protected function processDetails(Buffer $buffer)
{
// Decode into items
$items = $this->decode($buffer);
// Set the result to a new result instance
$result = new Result();
// Server is always dedicated
$result->add('dedicated', 1);
// These are the same no matter what mode the server is in
$result->add('hostname', $items[1]);
$result->add('num_players', (int) $items[2]);
$result->add('max_players', (int) $items[3]);
$result->add('gametype', $items[4]);
$result->add('map', $items[5]);
$result->add('roundsplayed', (int) $items[6]);
$result->add('roundstotal', (int) $items[7]);
$result->add('num_teams', (int) $items[8]);
// Set the current index
$index_current = 9;
// Pull the team count
$teamCount = $result->get('num_teams');
// Loop for the number of teams found, increment along the way
for ($id = 1; $id <= $teamCount; $id++, $index_current++) {
// Shows the tickets
$result->addTeam('tickets', $items[$index_current]);
// We add an id so we know which team this is
$result->addTeam('id', $id);
}
// Get and set the rest of the data points.
$result->add('targetscore', (int) $items[$index_current]);
$result->add('online', 1);
// Forced true, it seems $words[$index_current + 1] is always empty
$result->add('ranked', (int) $items[$index_current + 2]);
$result->add('punkbuster', (int) $items[$index_current + 3]);
$result->add('password', (int) $items[$index_current + 4]);
$result->add('uptime', (int) $items[$index_current + 5]);
$result->add('roundtime', (int) $items[$index_current + 6]);
$result->add('ip_port', $items[$index_current + 7]);
$result->add('punkbuster_version', $items[$index_current + 8]);
$result->add('join_queue', (int) $items[$index_current + 9]);
$result->add('region', $items[$index_current + 10]);
$result->add('pingsite', $items[$index_current + 11]);
$result->add('country', $items[$index_current + 12]);
//$result->add('quickmatch', (int) $items[$index_current + 13]); Supposed to be here according to R42 but is not
$result->add('blaze_player_count', (int) $items[$index_current + 13]);
$result->add('blaze_game_state', (int) $items[$index_current + 14]);
unset($items, $index_current, $teamCount, $buffer);
return $result->fetch();
}
/**
* Handle processing the status buffer
*
* @param Buffer $buffer
*
* @return array
*/
protected function processStatus(Buffer $buffer)
{
// Set the result to a new result instance
$result = new Result();
// By default dedicted
$result->add('dedicated', 1);
// Lets peek and see if the data starts with a \
if ($buffer->lookAhead(1) == '\\') {
// Burn the first one
$buffer->skip(1);
}
// Explode the data
$data = explode('\\', $buffer->getBuffer());
// No longer needed
unset($buffer);
// Init some vars
$numPlayers = 0;
$numTeams = 0;
$itemCount = count($data);
// Now lets loop the array
for ($x = 0; $x < $itemCount; $x += 2) {
// Set some local vars
$key = $data[$x];
$val = $data[$x + 1];
// Check for <variable>_<count> variable (i.e players)
if (($suffix = strrpos($key, '_')) !== false && is_numeric(substr($key, $suffix + 1))) {
// See if this is a team designation
if (substr($key, 0, $suffix) == 'teamname') {
$result->addTeam('teamname', $val);
$numTeams++;
} else {
// Its a player
if (substr($key, 0, $suffix) == 'playername') {
$numPlayers++;
}
$result->addPlayer(substr($key, 0, $suffix), utf8_encode($val));
}
} else {
// Regular variable so just add the value.
$result->add($key, $val);
}
}
// Add the player and team count
$result->add('num_players', $numPlayers);
$result->add('num_teams', $numTeams);
// Unset some stuff to free up memory
unset($data, $key, $val, $suffix, $x, $itemCount);
// Return the result
return $result->fetch();
}
/**
* Overload the default detail process since this version is different
*
* @param \GameQ\Buffer $buffer
*
* @return array
*/
protected function processDetails(Buffer $buffer)
{
// Set the result to a new result instance
$result = new Result();
$result->add('serverid', $buffer->readInt32());
// 0
$result->add('serverip', $buffer->readPascalString(1));
// empty
$result->add('gameport', $buffer->readInt32());
$result->add('queryport', $buffer->readInt32());
// 0
// We burn the first char since it is not always correct with the hostname
$buffer->skip(1);
// Read as a regular string since the length is incorrect (what we skipped earlier)
$result->add('servername', utf8_encode($buffer->readString()));
// The rest is read as normal
$result->add('mapname', utf8_encode($buffer->readPascalString(1)));
$result->add('gametype', $buffer->readPascalString(1));
$result->add('numplayers', $buffer->readInt32());
$result->add('maxplayers', $buffer->readInt32());
$result->add('currentwave', $buffer->readInt32());
unset($buffer);
return $result->fetch();
}