PHP的分析文件程序，要翻译成C#

?php /* ************************************************************************* * AOC Recorded Games Analyzer * --------------------------- * begin : Monday, December 3, 2007 * copyright : (c) 2007-2008 biegleux * email : biegleux(at)gma

/* *************************************************************************
* AOC Recorded Games Analyzer
* ---------------------------
* begin : Monday, December 3, 2007
* copyright : (c) 2007-2008 biegleux
* email : biegleux(at)gmail(dot)com
*
* recAnalyst v0.9.1 2008/11/07
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see http://www.gnu.org/licenses/.
*
* Thanks to bari [aocai-lj(at)infoseek.jp] for sharing mgx file format
* description.
*
* Note: Code is not fully optimized, any suggestions appreciated.
************************************************************************* */
/**
* Defines RecAnalyst class.
*
* @package recAnalyst
* @version $Id: recAnalyst.class.php 5 2008-11-08 15:04:10Z biegleux $
* @author biegleux
* @copyright copyright (c) 2008 biegleux
* @license http://www.opensource.org/licenses/gpl-3.0.html GNU General Public License version 3 (GPLv3)
* @link http://recanalyst.sourceforge.net/
* @filesource
* @todo rar extension support
* @todo test for server zlib/zip extension support
* @todo implement method/member for holding analyze time
*/

// uncomment following line if we want to debug
//define ('RA__DEBUG', true);
if (defined ('RA__DEBUG'))
{
error_reporting (E_ALL | E_STRICT);
}

/**#@+
*
* @ignore
*/
// error codes
define ('RA__NO_ERROR', 0x00);
define ('RA__FILE_NOT_SPECIFIED', 0x01);
define ('RA__FORMAT_NOT_SUPPORTED', 0x02);
define ('RA__UNABLE_TO_OPEN_ZIP_ARCHIVE', 0x03);
define ('RA__ZIP_ARCHIVE_EMPTY', 0x04);
define ('RA__OLD_FORMAT_VER', 0x05);
define ('RA__EMPTY_HEADER_STREAM', 0x06);
define ('RA__ERROR_IN_UNCOMPRESSED_STREAM', 0x07);
define ('RA__RAR_EXTENSION_NOT_INSTALLED', 0x08);
define ('RA__RAR_NOT_IMPLEMENTED', 0x09);
define ('RA__MORE_FILES_PER_ARCHIVE', 0x0A);
define ('RA__NO_RECGAME_FOUND', 0x0B);
define ('RA__ERROR_IN_HEADER_STREAM', 0x0C);

require_once ('recAnalyst.config.php');
require_once ('recAnalyst.consts.php');
require_once ('gameSettings.class.php');
require_once ('player.class.php');
require_once ('parentList.class.php');
require_once ('playerList.class.php');
require_once ('team.class.php');
require_once ('teamList.class.php');
/**#@-*/

/**
* RecAnalyst class
*
* RecAnalyst implements analyzing of recorded games.
*
* @package recAnalyst
*/
class RecAnalyst
{
const mgxExt = '.mgx';
const rarExt = '.rar';
const zipExt = '.zip';

/**
* Internal storage for new members.
*
* @var array
*/
private $data;

/**
* Input filename we wish to analyze.
*
* @var string
*/
public $fileName;

/**
* Internal stream containing header information.
*
* @var string
*/
private $headerStream;

/**
* Internal stream containing body information.
*
* @var string
*/
private $bodyStream;

/**
* Holds a code of the recent error.
*
* @var int
*/
private $lastError;

/**
* An array containing map data.
*
* $var array
*/
private $mapData;

/**
* Map width.
*
* @var int
*/
private $mapWidth;

/**
* Map height.
*
* @var int
*/
private $mapHeight;

/**
* Game settings information.
*
* @var GameSettings
*/
public $gameSettings;

/**
* List of players in the game.
*
* @var PlayerList
*/
public $playerList;

/**
* List of teams in the game.
*
* @var TeamList
*/
public $teams;

/**
* An array containing pre-game chat.
*
* @var array
*/
public $pregameChat;

/**
* An array containing in-game chat.
*
* @var array
*/
public $ingameChat;

/**
* An associative array containing "unit_type_id - unit_num" pairs.
*
* @var array
*/
public $units;

/**
* An associative multi-dimesional array containing "building_type_id - building_num" pairs for each player.
*
* @var array
*/
public $buildings;

/**
* An associative multi-dimesional array containing information about trading.
*
* @var array
*/
public $trading;

/**
* Constructor.
*
*/
public function __construct ()
{
$this->data = array ();
$this->fileName = '';
$this->headerStream = '';
$this->bodyStream = '';
$this->lastError = RA__NO_ERROR;
$this->gameSettings = new GameSettings ();
$this->playerList = new PlayerList ();
$this->teams = new TeamList ();
$this->pregameChat = array ();
$this->ingameChat = array ();
$this->units = array ();
$this->buildings = array ();
$this->mapData = array ();
$this->mapWidth = $this->mapHeight = 0;
$this->trading = array ();
}

/**
* Destructor.
*
*/
public function __destruct ()
{
}

/**
* Callback method for setting a property.
*
* @param mixed $nm
* @param mixed $val
*/
public function __set ($nm, $val)
{
$this->data[$nm] = $val;
}

/**
* Callback method for getting a property.
*
* @param mixed $nm
*/
public function __get ($nm)
{
return $this->data[$nm];
}

/**
* Returns code of the recent error.
*
* @return int
*/
public function getLastError ()
{
return $this->lastError;
}

/**
* Represents the error code as a string information.
*
* @param int $errCode error code
* @static
* @return string error string
*/
public static function errorCodeToString ($errCode)
{
switch ($errCode)
{
case RA__NO_ERROR:
$errString = 'No error occured.';
break;
case RA__FILE_NOT_SPECIFIED:
$errString = 'No file has been specified for analyzing.';
break;
case RA__FORMAT_NOT_SUPPORTED:
$errString = 'File format is not supported.';
break;
case RA__UNABLE_TO_OPEN_ZIP_ARCHIVE:
$errString = 'Unable to open zip archive.';
break;
case RA__ZIP_ARCHIVE_EMPTY:
$errString = 'Empty zip archive.';
break;
case RA__MORE_FILES_PER_ARCHIVE:
$errString = 'Only one file per archive is supported for analyzing.';
break;
case RA__OLD_FORMAT_VER:
$errString = 'Old mgx file format.';
break;
case RA__EMPTY_HEADER_STREAM:
$errString = 'Empty header stream.';
break;
case RA__ERROR_IN_UNCOMPRESSED_STREAM:
$errString = 'Error in uncompressed stream.';
break;
case RA__RAR_EXTENSION_NOT_INSTALLED:
$errString = 'Rar extension is not installed on server.';
break;
case RA__RAR_NOT_IMPLEMENTED:
$errString = 'Support for rar archives is not implemented.';
break;
case RA__NO_RECGAME_FOUND:
$errString = 'No recorded game has been found in archive.';
break;
case RA__ERROR_IN_HEADER_STREAM:
$errString = 'Error in header stream.';
break;
default:
$errString = '';
break;
}
return ($errString);
}

/**
* Converts game's time to string representation.
*
* @param int $time game time
* @param string $format desired string format
* @static
* @return string time in formatted string
*/
public static function gameTimeToString ($time, $format = '%02d:%02d:%02d')
{
if ($time == 0)
return '-';

$hour = (int)($time / 1000 / 3600);
$minute = ((int)($time / 1000 / 60)) % 60;
$second = ((int)($time / 1000)) % 60;

return sprintf ($format, $hour, $minute, $second);
}

/**
* Extracts header and body streams from an archive.
*
* @return bool
*/
private function extractStreamsFromArchive ()
{
if (!$this->fileName)
{
$this->lastError = RA__FILE_NOT_SPECIFIED;
return false;
}

$ext = strrchr ($this->fileName, '.');
if (strcasecmp ($ext, self::rarExt) != 0 && strcasecmp ($ext, self::zipExt) != 0)
{
$this->lastError = RA__FORMAT_NOT_SUPPORTED;
return false;
}

if (strcasecmp ($ext, self::rarExt) == 0)
{
if (!function_exists ('rar_open'))
{
$this->lastError = RA__RAR_EXTENSION_NOT_INSTALLED;
return false;
}
// stub
$this->lastError = RA__RAR_NOT_IMPLEMENTED;
return false;
}

if (strcasecmp ($ext, self::zipExt) == 0)
{
$zip = new ZipArchive ();

if ($zip->open ($this->fileName) !== true)
{
$this->lastError = RA__UNABLE_TO_OPEN_ZIP_ARCHIVE;
return false;
}

if ($zip->numFiles == 0)
{
$zip->close ();
$this->lastError = RA__ZIP_ARCHIVE_EMPTY;
return false;
}

if ($zip->numFiles != 1)
{
$zip->close ();
$this->lastError = RA__MORE_FILES_PER_ARCHIVE;
return false;
}

$mgx_found = false;

for ($i = 0; false !== ($stat = $zip->statIndex ($i)); $i++)
{
// skip directories and 0-bytes files
if (!$stat['size'])
{
continue;
}

// skip non-mgx files
$ext = strrchr ($stat['name'], '.');
if (strcasecmp ($ext, self::mgxExt) != 0)
{
continue;
}

// get a file handler to the entry
if (!($fp = $zip->getStream ($stat['name'])))
{
continue;
}

$mgx_found = true;

// read data
$packed_data = fread ($fp, 4);

if ($packed_data === false || strlen ($packed_data) {
$zip->close ();
$this->lastError = RA__ERROR_IN_HEADER_STREAM;
return false;
}

$unpacked_data = unpack ("V", $packed_data);
$header_len = $unpacked_data[1];

if ($header_len == 0)
{
$zip->close ();
$this->lastError = RA__OLD_FORMAT_VER;
return false;
}

// skip next_pos
$packed_data = fread ($fp, 4);
$header_len -= 8;

// TODO: getMemoryLimit ()
if ($header_len > 1048576) // 1MB
{
$zip->close ();
$this->lastError = RA__ERROR_IN_HEADER_STREAM;
return false;
}

$read = 0;
while ($read {
$read += strlen ($buff);
$this->headerStream .= $buff;
}

$read = 0;
while (!feof ($fp))
{
$buff = fread ($fp, 1024 * 8);
$this->bodyStream .= $buff;
}

unset ($buff);
fclose ($fp);
$zip->close ();

return true;
} // endfor

$zip->close ();

if (!$mgx_found)
{
$this->lastError = RA__NO_RECGAME_FOUND;
return false;
}
} // end zip uncompression
}

/**
* Uncompresses header stream.
*
* @return string|bool uncompressed stream or false if an error occured
*/
private function uncompressHeaderStream ()
{
if (!$this->headerStream)
{
$this->lastError = RA__EMPTY_HEADER_STREAM;
return false;
}

//TODO: getMemoryLimit ()
$this->headerStream = @gzinflate ($this->headerStream, 4194304); // 4MB

if (!$this->headerStream)
{
$this->lastError = RA__ERROR_IN_HEADER_STREAM;
return false;
}

return true;
}

/**
* Analyzes header stream.
*
* @return bool true if analyzed successfully, otherwise false
*/
private function analyzeHeaderStream ()
{
global $RA__MAPS;
global $RA__GAME_STYLES;
global $RA__DIFFICULTY_LEVELS;
global $RA__GAME_TYPES;
global $RA__GAME_SPEEDS;
global $RA__CIVS;

// initialize variables
$constant2 = pack ('c*', 0x9A, 0x99, 0x99, 0x99, 0x99, 0x99, 0xF9, 0x3F);
$separator = pack ('c*', 0x9D, 0xFF, 0xFF, 0xFF);
$unknown_const2 = pack ('c*', 0x98, 0x9E, 0x00, 0x00, 0x02, 0x0B);
$trigger_info_pos = $game_setting_pos = 0;

$string_id = pack ('c*', 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);

$pos = 0;
$m_header_len = strlen ($this->headerStream);

$len = strlen ($constant2);
$pos = ($m_header_len - $len);

$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
// TODO: use substr_compare
while ($pos > 0)
{
if (strcmp ($buff, $constant2) == 0)
{
$trigger_info_pos = $pos;
break;
}
$pos -= $len + 1;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
}

if ($trigger_info_pos == 0)
{
$this->lastError = RA__ERROR_IN_UNCOMPRESSED_STREAM;
return false;
}

// getting Game_settings position
$len = strlen ($separator);
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
while ($pos > 0)
{
if (strcmp ($buff, $separator) == 0)
{
$game_setting_pos = $pos;
break;
}

$pos -= $len + 1;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
}

if ($game_setting_pos == 0)
{
// not found
$this->lastError = RA__ERROR_IN_UNCOMPRESSED_STREAM;
return false;
}

/***************************************************************************************
note: Victory & Achievement data not found as described in mgx format description
obtaining Achievement data should be called after knowing num_player as it is required

// getting Victory position, first is Disables
$pos -= 8;
$victory_pos = 0;
$separator_first_pos = 0;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
while ($pos > 0)
{
if (strcmp ($buff, $separator) == 0)
break;
$pos -= $len + 1;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
}
if ($pos != 0)
{
$pos -= 8;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
while ($pos > 0)
{
if (strcmp ($buff, $separator) == 0)
{
$victory_pos = $pos;
break;
}
$pos -= $len + 1;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
}
}
if ($victory_pos != 0)
{
$pos -= 8;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
while ($pos > 0)
{
if (strcmp ($buff, $separator) == 0)
{
$separator_first_pos = $pos;
break;
}
$pos -= $len + 1;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
}

$pos = $victory_pos;

// here should be victory condition, but isn't
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$conquest = $unpacked_data[1];
if (conquest == 0)
{
$this->gameSettings->victory = 'custom';
$pos += 4;

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$relics = $unpacked_data[1];
$pos += 4;
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$explored = $unpacked_data[1];
$pos += 4;
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$all = $unpacked_data[1];
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$mode = $unpacked_data[1];
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$score = $unpacked_data[1];
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$time = $unpacked_data[1];

if ($relics != 0)
{
$this->gameSettings->victory = sprintf ('Gain %d relics', $relics);
}
elseif ($explored != 0)
{
$this->gameSettings->victory = sprintf ('Percentage of explored map: %d', $explored);
}
else
{
switch ($mode)
{
case 0:
$this->gameSettings->victory = 'Normal';
break;
case 1:
$this->gameSettings->victory = 'Conquest';
break;
case 2:
$this->gameSettings->victory = sprintf ('Score Limit: %d', $score);
break;
case 3:
$this->gameSettings->victory = sprintf ('Time Limit: %d', $time);
break;
}
}

}
elseif ($condition == 1)
{
$this->gameSettings->victory = 'Conquest';
}
}
if ($separator_first_pos != 0)
{
$string_id_pos = 0;
$len = strlen ($string_id);
$pos = $separator_first_pos - $len;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
while ($pos > 0)
{
if (strcmp ($buff, $string_id) == 0)
{
$string_id_pos = $pos;
break;
}
$pos -= $len + 1;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
}
if ($string_id_pos != 0)
{
$pos = $string_id_pos - $len;
$pos -= 4096;
$pos -= 4;
$pos -= 4;

// num_player is not known till now, need to be called after obtaining it
$pos -= 1473 * $num_player;
// here should start Achievement, but doesn't :-(
$pos += 13;
$packed_data = substr ($this->headerStream, $pos, 4);
$unpacked_data = unpack ("V", $packed_data);
$total_point = $unpacked_data[1];
//...
}
}
***************************************************************************************/

// getting Game_Settings data
// skip negative[2]
$pos = $game_setting_pos + 8;

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$map_id = $unpacked_data[1];

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$difficulty = $unpacked_data[1];
// skip unknown
$pos += 4;

if (array_key_exists ($map_id, $RA__MAPS))
{
$this->gameSettings->map = $RA__MAPS[$map_id][0];
$this->gameSettings->gameStyle = $RA__GAME_STYLES[0];
}
else
{
$this->gameSettings->gameStyle = $RA__GAME_STYLES[2];
}

if (array_key_exists ($difficulty, $RA__DIFFICULTY_LEVELS))
{
$this->gameSettings->difficultyLevel = $RA__DIFFICULTY_LEVELS[$difficulty];
}

// getting Player_info data
for ($i = 0; $i {
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$player_data_index = $unpacked_data[1];

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$human = $unpacked_data[1];

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$name_len = $unpacked_data[1];

$playername = substr ($this->headerStream, $pos, $name_len); $pos += $name_len;

// 0x00:invalid player, 0x02:human, 0x04:computer
// index 0 is GAIA player
if ($human == 0x00)
continue;
// sometimes very rarely index is 1
if ($human == 0x01)
continue;
if ($human != 0x00 && $i != 0)
{
$player = new Player ();
$player->name = $playername;
$player->index = $player_data_index;
$player->human = ($human == 0x02);

$this->playerList->addPlayer ($player);
}
} // endfor

// Trigger_info
$pos = $trigger_info_pos + 1;

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$num_trigger = $unpacked_data[1];

if ($num_trigger == 0)
{
$this->gameSettings->isScenario = false;

// Other_data
for ($i = 0; $i {
$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$team = $unpacked_data[1];

if (($i + 1) playerList->getCount ())
{
if ($player = $this->playerList->getPlayer ($i))
{
$player->team = $team - 1;
}
}
}

// skip unknown[13]
$pos += 13;

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$pop_limit = $unpacked_data[1];

$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$game_type = $unpacked_data[1];

$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$lock_diplomacy = $unpacked_data[1];

$this->gameSettings->popLimit = $pop_limit;
$this->gameSettings->gameType = $RA__GAME_TYPES[$game_type];
$this->gameSettings->lockDiplomacy = ($lock_diplomacy == 0x01);

// here comes pre-game chat
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$num_chat = $unpacked_data[1];
for ($i = 0; $i {
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$chat_len = $unpacked_data[1];

// 0-length chat exists
if ($chat_len == 0)
{
continue;
}

$chat = substr ($this->headerStream, $pos, $chat_len); $pos += $chat_len;

if ($chat[0] == '@' && $chat[1] == '#' && $chat[2] >= '1' && $chat[2] {
$chat = rtrim ($chat); // throw null-termination character
$this->pregameChat[] = $chat;
}
}
unset ($chat);
}
else
{
$this->gameSettings->isScenario = true;
$this->gameSettings->map = '';
$this->gameSettings->gameType = $RA__GAME_TYPES[3];
$this->gameSettings->gameStyle = $RA__GAME_STYLES[2];
}

// skip AI_info if exists
$pos = 0x0C;
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$include_ai = $unpacked_data[1];

if ($include_ai == 0x01)
{
$pos += 2;
$packed_data = substr ($this->headerStream, $pos, 2); $pos += 2;
$unpacked_data = unpack ("v", $packed_data);
$num_string = $unpacked_data[1];
$pos += 4;
for ($i = 0; $i {
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$string_length = $unpacked_data[1];
$pos += $string_length;
}
$pos += 6;
// AI_data
for ($i = 0; $i {
$pos += 10;
$packed_data = substr ($this->headerStream, $pos, 2); $pos += 2;
$unpacked_data = unpack ("v", $packed_data);
$num_rule = $unpacked_data[1];
$pos += 4;
$pos = $pos + (400 * $num_rule);
}
$pos += 5544;
}

// getting data
$pos += 4;
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$game_speed = $unpacked_data[1];

$pos += 37;
$packed_data = substr ($this->headerStream, $pos, 2); $pos += 2;
$unpacked_data = unpack ("v", $packed_data);
$rec_player_ref = $unpacked_data[1];

$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$num_player = $unpacked_data[1];

$rec_player_ref--; // 0 is GAIA, not appears in playerList
$num_player--;
$this->gameSettings->speed = $RA__GAME_SPEEDS[$game_speed];
if ($player = $this->playerList->getPlayer ($rec_player_ref))
{
$player->owner = true;
}

if ($num_player playerList->getCount ())
{
$this->gameSettings->inGameCoop = true;
}

// getting map
$pos += 62;
$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$map_size_x = $unpacked_data[1];
$this->mapWidth = $map_size_x;

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$map_size_y = $unpacked_data[1];
$this->mapHeight = $map_size_y;

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$num_unknown_data = $unpacked_data[1];
// unknown data
for ($i = 0; $i {
$pos += 1275;
$pos += $map_size_x * $map_size_y;

$packed_data = substr ($this->headerStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$num_float = $unpacked_data[1];
/*
if (num_float != 0x29)
{
// error = 1
break;
}
*/
$pos += 4 * $num_float;
$pos += 4;
}
$pos += 2;

// map data
// if error == 0 { do following + set flag map_loaded }
$x = $y = 1;
for ($i = 0; $i {
// terrain_id
$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$terrain_id = $unpacked_data[1];
// elevation
$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$elevation = $unpacked_data[1];
if ($x == $map_size_x + 1)
{
$x = 1;
$y++;
}
$this->mapData[$x][$y][0] = $terrain_id;
// TODO: elevation
// we do not get elevation (memory exhaustive)
// $this->mapData[$x][$y][1] = $elevation;
$x++;
}

$pos += 128;
$pos += $map_size_x * $map_size_y * 4;
$pos += 15;
/*
// TODO: test for behavior if there is a Computer
// getting Player_info position
$len = strlen ($unknown_const2);
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
while ($pos {
if (strcmp ($buff, $unknown_const2) == 0)
{
break;
}
$pos -= $len - 1;
$buff = substr ($this->headerStream, $pos, $len); $pos += $len;
}
*/
$pos += 5138;

foreach ($this->playerList as $player)
{
// skip cooping player, he/she has no data in Player_info
$player_ = $this->playerList->getPlayerByIndex ($player->index);

if ($player_ && ($player_ !== $player) && $player_->civId)
{
$player->civId = $player_->civId;
$player->civ = $player_->civ;
$player->colorId = $player_->colorId;
$player->isCooping = true;
continue;
}
$playerName = $player->name;

while ($pos {
$buff = substr ($this->headerStream, $pos, strlen ($playerName));

if (strcmp ($buff, $playerName) == 0)
{
break;
}
$pos++;
}
$pos += strlen ($playerName);

// skip data (first byte is null char player's name terminator)
$pos += 817;
// civilization
$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$civilization = $unpacked_data[1];

$player->civId = $civilization;
$player->civ = $RA__CIVS[$civilization][0];

// skip unknown9[3]
$pos += 3;
// player_color
$packed_data = substr ($this->headerStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$player_color = $unpacked_data[1];

$player->colorId = $player_color;

$pos += 4299;
} // endfor

// initialize variables
$con1 = pack ('c*', 0x3A, 0x20);
$con2 = pack ('c*', 0xA1, 0x47);

$LANGUAGES = array (
'en' => pack ('c*', 0x4D, 0x61, 0x70, 0x20, 0x54, 0x79, 0x70, 0x65),
'cz' => pack ('c*', 0x54, 0x79, 0x70, 0x20, 0x6D, 0x61, 0x70, 0x79),
'jp' => pack ('c*', 0x83, 0x7D, 0x83, 0x62, 0x83, 0x76, 0x82, 0xCC, 0x8E, 0xED, 0x97, 0xDE),
'cn' => pack ('c*', 0xB5, 0xD8, 0xCD, 0xBC, 0xC0, 0xE0, 0xD0, 0xCD),
'sp' => pack ('c*', 0x54, 0x69, 0x70, 0x6F, 0x20, 0x64, 0x65, 0x20, 0x6D, 0x61, 0x70, 0x61),
'de' => pack ('c*', 0x4B, 0x61, 0x72, 0x74, 0x65, 0x6E, 0x74, 0x79, 0x70),
'cn2' => pack ('c*', 0xA6, 0x61, 0xB9, 0xCF, 0xC3, 0xFE, 0xA7, 0x4F),
'kr' => pack ('c*', 0xC7, 0xA5, 0xC1, 0xD8, 0x0A, 0xC0, 0xDA, 0xBF, 0xF8),
'fr' => pack ('c*', 0x54, 0x79, 0x70, 0x65, 0x20, 0x64, 0x65, 0x20, 0x63, 0x61, 0x72, 0x74, 0x65, 0xA0),
'it' => pack ('c*', 0x54, 0x69, 0x70, 0x6F, 0x20, 0x64, 0x69, 0x20, 0x6D, 0x61, 0x70, 0x70, 0x61),
'sp2' => pack ('c*', 0x54, 0x69, 0x70, 0x6F, 0x20, 0x64, 0x65, 0x20, 0x4D, 0x61, 0x70, 0x61),
'ur' => pack ('c*', 0xD2, 0xE8, 0xEF, 0x20, 0xCA, 0xE0, 0xF0, 0xF2, 0xFB));

// getting map name (only if map is custom (44) and game type is not scenario (game_type still $00 in scenarios)
// if map_id = 32 (Random Land Map), it is possible to obtain map if it's written in english
if (!array_key_exists ($map_id, $RA__MAPS) && $game_type != 0x03 && !$this->gameSettings->isScenario)
{
$pos = $game_setting_pos - 11520;

$mapFound = false;

$buff = substr ($this->headerStream, $pos, 2); $pos += 2;
// searching up to -100000 bytes, than stop
while ($pos > $game_setting_pos - 11520 - 100000 && !$mapFound)
{
if (strcmp ($buff, $con1) == 0 || strcmp ($buff, $con2) == 0)
{
$pos -= 2;

foreach ($LANGUAGES as $val)
{
$pos -= strlen ($val);
$map_name = substr ($this->headerStream, $pos, strlen ($val)); $pos += strlen ($val);

if (strcmp ($map_name, $val) == 0)
{
$mapName = '';
$pos += 2; // skip ': '

for ($i = 0; $i {
$buff = substr ($this->headerStream, $pos, 1); $pos += 1;

if ($buff != chr (0x0A))
{
$mapName .= $buff;
}
else
{
$mapFound = true;
break;
}
} // endfor
break;
} // endif
} // end foreach
} // endif

$pos -= 3;
$buff = substr ($this->headerStream, $pos, 2); $pos += 2;
} // endwhile

$this->gameSettings->map = ($mapFound) ? $mapName : $RA__GAME_STYLES[2];
} // endif

// build teams
foreach ($this->playerList as $player)
{
if ($player->team == 0)
{
$found = false;
foreach ($this->teams as $team)
{
if ($team->getIndex () != $player->team)
{
continue;
}
foreach ($team as $player_)
{
if ($player_->index == $player->index)
{
$team->addPlayer ($player);
$found = true;
break;
}
}
if ($found)
{
break;
}
}
if (!$found)
{
$team = new Team ();
$team->addPlayer ($player);
$this->teams->addTeam ($team);
}
}
else
{
if ($team = $this->teams->getTeamByIndex ($player->team))
{
$team->addPlayer ($player);
}
else
{
$team = new Team ();
$team ->addPlayer ($player);
$this->teams->addTeam ($team);
}
}
}

return true;
}

/**
* Analyzes body stream.
*
* @return bool true if successfully analyzed, otherwise false
*/
private function analyzeBodyStream ()
{
$time_cnt = $pos = $trading_cnt = 0;
$m_body_len = strlen ($this->bodyStream);
$age_flag = array (0, 0, 0, 0, 0, 0, 0, 0);

if (defined ('RA__DEBUG'))
{
global $RA__RESOURCES;
}

while ($pos {
$packed_data = substr ($this->bodyStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$type = $unpacked_data[1];
if (defined ('RA__DEBUG'))
{
printf (nl2br ("type: %d/n"), $type);
}

switch ($type)
{
case 4:
$packed_data = substr ($this->bodyStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$command = $unpacked_data[1];
if ($command == 0x01F4)
{
// Game_start
$pos += 20;
}
elseif ($command == -1)
{
// Chat
$packed_data = substr ($this->bodyStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$chat_len = $unpacked_data[1];

for ($i = 0; $i playerList->getCount (); $i++)
{
if (!($player = $this->playerList->getPlayer ($i)))
{
continue;
}

if ($player->feudalTime != 0 && $player->feudalTime {
$this->ingameChat[] = sprintf ('%d@#0%s advanced to Feudal Age', $player->feudalTime, $player->name);
$age_flag[$i] = 1;
}
if ($player->castleTime != 0 && $player->castleTime {
$this->ingameChat[] = sprintf ('%d@#0%s advanced to Castle Age', $player->castleTime, $player->name);
$age_flag[$i] = 1;
}
if ($player->imperialTime != 0 && $player->imperialTime {
$this->ingameChat[] = sprintf ('%d@#0%s advanced to Imperial Age', $player->imperialTime, $player->name);
$age_flag[$i] = 1;
}
}

$chat = substr ($this->bodyStream, $pos, $chat_len); $pos += $chat_len;

if ($chat[0] == '@' && $chat[1] == '#' && $chat[2] >= '1' && $chat[2] {
$chat = rtrim ($chat); // throw null-termination character
if (substr ($chat, 3, 2) == '--' && substr ($chat, -2) == '--')
{
}
else
{
$this->ingameChat[] = sprintf ('%d%s', $time_cnt, $chat);
}
}
}
break;
case 2:
// Sync
$packed_data = substr ($this->bodyStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$time_cnt += $unpacked_data[1]; // time_cnt is in miliseconds
$packed_data = substr ($this->bodyStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$unknown = $unpacked_data[1];
if ($unknown == 0)
{
$pos += 28;
}
$pos += 12;
break;
case 1:
// Command
$packed_data = substr ($this->bodyStream, $pos, 4); $pos += 4;
$unpacked_data = unpack ("V", $packed_data);
$length = $unpacked_data[1];

$packed_data = substr ($this->bodyStream, $pos, 1);
$unpacked_data = unpack ("C", $packed_data);
$command = $unpacked_data[1];

if (defined ('RA__DEBUG'))
{
$packed_data = substr ($this->bodyStream, $pos, 2);
$unpacked_data = unpack ("v", $packed_data);
$cmd = $unpacked_data[1];

$format = nl2br ("(%s): 0x%02x - 0x%02x -> len: %d/n");
printf ($format, self::gameTimeToString ($time_cnt), $cmd, $command, $length);
}

if (defined ('RA__DEBUG'))
{
$output = '';
for ($i = $pos + 1; $i {
$packed_data = substr ($this->bodyStream, $i, 1);
$unpacked_data = unpack ("C", $packed_data);
$c = $unpacked_data[1];
$output .= $c . '|';
}
print (nl2br ($output . "/n"));
}

switch ($command)
{
case 0x0B:
$pos += 1;
$packed_data = substr ($this->bodyStream, $pos, 1); $pos += 1;
$unpacked_data = unpack ("C", $packed_data);
$player_number = $unpacked_data[1];
$pos += 2;
if ($player = $this->playerList->getPlayerByIndex ($player_number))
{
$player->resignTime = $time_cnt;
$this->ingameChat[] = sprintf ('%d@#0%s resigned', $player->resignTime, $player->name);

if (defined ('RA__DEBUG'))
{
$format = nl2br ("(%s) resigned player #%d: %s/n");
printf ($format, self::gameTimeToString ($time_cnt), $player_number, $player->name);
}
}
$pos += $length - 4; // different from mgx format description
break;
case 0x65: // researches
$pos += 8;
// player_id
$packed_data = substr ($this->bodyStream, $pos, 2); $pos += 2;
$unpacked_data = unpack ("v", $packed_data);
$player_id = $unpacked_data[1];
// research_id
$packed_data = substr ($this->bodyStream, $pos, 2); $pos += 2;
$unpacked_data = unpack ("v", $packed_data);
$research_id = $unpacked_data[1];
if ($research_id == 101)
{
// feudal time
if ($player = $this->playerList->getPlayerByIndex ($player_id))
{
$player->feudalTime = $time_cnt + 130 * 1000; // + research time (2:10)
}
}
if ($research_id == 102)
{
// castle time
if ($player = $this->playerList->getPlayerByIndex ($player_id))
{
// persians?
$player->castleTime = ($player->civId == 0x08) ? $time_cnt + 144 * 1000 : $time_cnt + 160 * 1000;
}
}
if ($research_id == 103)
{
// imperial time
if ($player = $this->playerList->getPlayerByIndex ($player_id))
{
// persians?
$player->imperialTime = ($player->civId == 0x08) ? $time_cnt + 162 * 1000 : $time_cnt + 190 * 1000;
}
}
// else
{
if ($player = $this->playerList->getPlayerByIndex ($player_id))
{
$player->researches[$research_id] = $time_cnt;
}
}
if (defined ('RA__DEBUG'))
{
$format = nl2br ("#%d -> %d/n");
printf ($format, $player_id, $research_id);
}
$pos += ($length - 12);
break;
case 0x77