示例#1
0
 /**
  * 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();
 }
示例#2
0
 /**
  * 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();
 }
示例#3
0
 /**
  * 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);
 }
示例#4
0
 /**
  * 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);
     }
 }
示例#5
0
 /**
  * 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();
 }
示例#6
0
 /**
  * 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);
 }
示例#7
0
 /**
  * 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();
 }
示例#8
0
 /**
  * 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();
 }
示例#9
0
 /**
  * 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();
 }
示例#10
0
 /**
  * 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);
 }
示例#11
0
 /**
  * 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));
         }
     }
 }
示例#12
0
 /**
  * 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();
 }
示例#13
0
 /**
  * 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();
 }
示例#14
0
 /**
  * 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();
 }