☰

Extra Statistics

Generate additional statistical data in the dungeon and duel report pages

  1. //-----------------------------------------------------------------------------
  2. // [WoD] Extra Statistics
  3. // Version 1.20, 2010-04-15
  4. // Copyright (c) Fenghou, Tomy
  5. // This script can generate additional statistical data in the dungeon and duel report pages.
  6. // When you entered the details or statistics page of reports, a new button will appear beside
  7. //   the details button. At the details page, the new button is "Extra Stat", which will show
  8. //   the statistics of the current level when you click it. At the statistics page, the new
  9. //   button is "Entire Extra Stat", which will show the statistics of entire dungeon.
  10. //-----------------------------------------------------------------------------
  11.  
  12. //-----------------------------------------------------------------------------
  13. // If you want to add a new Stat table, you should create a new sub class of CInfoList,
  14. //   and use CStat::RegInfoList() to register your new info list.
  15. // A detailed example is CILItemDamage.
  16. //-----------------------------------------------------------------------------
  17.  
  18. // ==UserScript==
  19. // @name		Extra Statistics
  20. // @namespace		fenghou
  21. // @version             1.20
  22. // @description		Generate additional statistical data in the dungeon and duel report pages
  23. // @include		http*://*.world-of-dungeons.*/wod/spiel/*dungeon/report.php*
  24. // @include		http*://*.world-of-dungeons.*/wod/spiel/tournament/*duell.php*
  25. // @include     file:///*f1.htm
  26. // ==/UserScript==
  27.  
  28.  
  29. // COMMON FUNCTIONS ///////////////////////////////////////////////////////////
  30.  
  31. function $(id) {return document.getElementById(id);}
  32.  
  33.  
  34. // Choose contents of the corresponding language
  35. // Contents: {Name1 : [lang1, lang2, ...], Name2 : [lang1, lang2, ...], ...}
  36. // return: Local contents, or null
  37. // It will edit the input contents directly, so the returned object is not necessary
  38. function GetLocalContents(Contents)
  39. 	{
  40. 	function GetLanguageId()
  41. 		{
  42. 		var langText = null;
  43. 		var allMetas = document.getElementsByTagName("meta");
  44. 		for (var i = 0; i < allMetas.length; ++i)
  45. 			{
  46. 			if (allMetas[i].httpEquiv == "Content-Language")
  47. 				{
  48. 				langText = allMetas[i].content;
  49. 				break;
  50. 				}
  51. 			}
  52. 		if (langText == null)
  53. 			return false;
  54.  
  55. 		switch (langText)
  56. 			{
  57. 			case "en":
  58. 				return 0;
  59. 			case "cn":
  60. 				return 1;
  61. 			default:
  62. 				return null;
  63. 			}
  64. 		}
  65.  
  66. 	var nLangId = GetLanguageId();
  67. 	if (nLangId == null)
  68. 		return null;
  69.  
  70. 	if (Contents instanceof Object)
  71. 		{
  72. 		for (var name in Contents)
  73. 			Contents[name] = Contents[name][nLangId];
  74. 		return Contents;
  75. 		}
  76. 	else
  77. 		return null;
  78. 	}
  79.  
  80.  
  81. function CompareString(a, b)
  82. 	{
  83. 	a = a || "";
  84. 	b = b || "";
  85. 	return a.toLowerCase().localeCompare( b.toLowerCase() );
  86. 	}
  87.  
  88.  
  89. function CreateElementHTML(Name, Content /* , [AttrName1, AttrValue1], [AttrName2, AttrValue2], ... */)
  90. 	{
  91. 	var HTML = '<' + Name;
  92.  
  93. 	for (var i = 2; i < arguments.length; ++i)
  94. 		HTML += ' ' + arguments[i][0] + '="' + arguments[i][1] + '"';
  95.  
  96. 	HTML += (Content != null && Content != "") ? ('>' + Content + '</' + Name + '>') : (' />');
  97.  
  98. 	return HTML;
  99. 	}
  100.  
  101.  
  102. function DbgMsg(Text) {if (DEBUG) alert(Text);}
  103.  
  104.  
  105. // EXTERN FUNCTIONS ///////////////////////////////////////////////////////////
  106.  
  107. /**
  108.  * A utility function for defining JavaScript classes.
  109.  *
  110.  * This function expects a single object as its only argument.  It defines
  111.  * a new JavaScript class based on the data in that object and returns the
  112.  * constructor function of the new class.  This function handles the repetitive
  113.  * tasks of defining classes: setting up the prototype object for correct
  114.  * inheritance, copying methods from other types, and so on.
  115.  *
  116.  * The object passed as an argument should have some or all of the
  117.  * following properties:
  118.  *
  119.  *      name: The name of the class being defined.
  120.  *            If specified, this value will be stored in the classname
  121.  *            property of the prototype object.
  122.  *
  123.  *    extend: The constructor of the class to be extended. If omitted,
  124.  *            the Object( ) constructor will be used. This value will
  125.  *            be stored in the superclass property of the prototype object.
  126.  *
  127.  * construct: The constructor function for the class. If omitted, a new
  128.  *            empty function will be used. This value becomes the return
  129.  *            value of the function, and is also stored in the constructor
  130.  *            property of the prototype object.
  131.  *
  132.  *   methods: An object that specifies the instance methods (and other shared
  133.  *            properties) for the class. The properties of this object are
  134.  *            copied into the prototype object of the class. If omitted,
  135.  *            an empty object is used instead. Properties named
  136.  *            "classname", "superclass", and "constructor" are reserved
  137.  *            and should not be used in this object.
  138.  *
  139.  *   statics: An object that specifies the static methods (and other static
  140.  *            properties) for the class. The properties of this object become
  141.  *            properties of the constructor function. If omitted, an empty
  142.  *            object is used instead.
  143.  *
  144.  *   borrows: A constructor function or array of constructor functions.
  145.  *            The instance methods of each of the specified classes are copied
  146.  *            into the prototype object of this new class so that the
  147.  *            new class borrows the methods of each specified class.
  148.  *            Constructors are processed in the order they are specified,
  149.  *            so the methods of a class listed at the end of the array may
  150.  *            overwrite the methods of those specified earlier. Note that
  151.  *            borrowed methods are stored in the prototype object before
  152.  *            the properties of the methods object above. Therefore,
  153.  *            methods specified in the methods object can overwrite borrowed
  154.  *            methods. If this property is not specified, no methods are
  155.  *            borrowed.
  156.  *
  157.  *  provides: A constructor function or array of constructor functions.
  158.  *            After the prototype object is fully initialized, this function
  159.  *            verifies that the prototype includes methods whose names and
  160.  *            number of arguments match the instance methods defined by each
  161.  *            of these classes. No methods are copied; this is simply an
  162.  *            assertion that this class "provides" the functionality of the
  163.  *            specified classes. If the assertion fails, this method will
  164.  *            throw an exception. If no exception is thrown, any
  165.  *            instance of the new class can also be considered (using "duck
  166.  *            typing") to be an instance of these other types.  If this
  167.  *            property is not specified, no such verification is performed.
  168.  **/
  169. function DefineClass(data) {
  170.     // Extract the fields we'll use from the argument object.
  171.     // Set up default values.
  172.     var classname = data.name;
  173.     var superclass = data.extend || Object;
  174.     var constructor = data.construct || function(){};
  175.     var methods = data.methods || {};
  176.     var statics = data.statics || {};
  177.     var borrows;
  178.     var provides;
  179.  
  180.     // Borrows may be a single constructor or an array of them.
  181.     if (!data.borrows) borrows = [];
  182.     else if (data.borrows instanceof Array) borrows = data.borrows;
  183.     else borrows = [ data.borrows ];
  184.  
  185.     // Ditto for the provides property.
  186.     if (!data.provides) provides = [];
  187.     else if (data.provides instanceof Array) provides = data.provides;
  188.     else provides = [ data.provides ];
  189.  
  190.     // Create the object that will become the prototype for our class.
  191.     var proto = new superclass( );
  192.  
  193.     // Delete any noninherited properties of this new prototype object.
  194.     for(var p in proto)
  195.         if (proto.hasOwnProperty(p)) delete proto[p];
  196.  
  197.     // Borrow methods from "mixin" classes by copying to our prototype.
  198.     for(var i = 0; i < borrows.length; i++) {
  199.         var c = data.borrows[i];
  200.         borrows[i] = c;
  201.         // Copy method properties from prototype of c to our prototype
  202.         for(var p in c.prototype) {
  203.             if (typeof c.prototype[p] != "function") continue;
  204.             proto[p] = c.prototype[p];
  205.         }
  206.     }
  207.     // Copy instance methods to the prototype object
  208.     // This may overwrite methods of the mixin classes
  209.     for(var p in methods) proto[p] = methods[p];
  210.  
  211.     // Set up the reserved "constructor", "superclass", and "classname"
  212.     // properties of the prototype.
  213.     proto.constructor = constructor;
  214.     proto.superclass = superclass;
  215.     // classname is set only if a name was actually specified.
  216.     if (classname) proto.classname = classname;
  217.  
  218.     // Verify that our prototype provides all of the methods it is supposed to.
  219.     for(var i = 0; i < provides.length; i++) {  // for each class
  220.         var c = provides[i];
  221.         for(var p in c.prototype) {   // for each property
  222.             if (typeof c.prototype[p] != "function") continue;  // methods only
  223.             if (p == "constructor" || p == "superclass") continue;
  224.             // Check that we have a method with the same name and that
  225.             // it has the same number of declared arguments.  If so, move on
  226.             if (p in proto &&
  227.                 typeof proto[p] == "function" &&
  228.                 proto[p].length == c.prototype[p].length) continue;
  229.             // Otherwise, throw an exception
  230.             throw new Error("Class " + classname + " does not provide method "+
  231.                             c.classname + "." + p);
  232.         }
  233.     }
  234.  
  235.     // Associate the prototype object with the constructor function
  236.     constructor.prototype = proto;
  237.  
  238.     // Copy static properties to the constructor
  239.     for(var p in statics) constructor[p] = statics[p];
  240.  
  241.     // Finally, return the constructor function
  242.     return constructor;
  243. }
  244.  
  245.  
  246. /**
  247.  * Throughout, whitespace is defined as one of the characters
  248.  *  "\t" TAB \u0009
  249.  *  "\n" LF  \u000A
  250.  *  "\r" CR  \u000D
  251.  *  " "  SPC \u0020
  252.  *
  253.  * This does not use Javascript's "\s" because that includes non-breaking
  254.  * spaces (and also some other characters).
  255.  */
  256.  
  257.  
  258. /**
  259.  * Determine whether a node's text content is entirely whitespace.
  260.  *
  261.  * @param nod  A node implementing the |CharacterData| interface (i.e.,
  262.  *             a |Text|, |Comment|, or |CDATASection| node
  263.  * @return     True if all of the text content of |nod| is whitespace,
  264.  *             otherwise false.
  265.  */
  266. function is_all_ws( nod )
  267. {
  268.   // Use ECMA-262 Edition 3 String and RegExp features
  269.   return !(/[^\t\n\r ]/.test(nod.data));
  270. }
  271.  
  272.  
  273. /**
  274.  * Determine if a node should be ignored by the iterator functions.
  275.  *
  276.  * @param nod  An object implementing the DOM1 |Node| interface.
  277.  * @return     true if the node is:
  278.  *                1) A |Text| node that is all whitespace
  279.  *                2) A |Comment| node
  280.  *             and otherwise false.
  281.  */
  282.  
  283. function is_ignorable( nod )
  284. {
  285.   return ( nod.nodeType == 8) || // A comment node
  286.          ( (nod.nodeType == 3) && is_all_ws(nod) ); // a text node, all ws
  287. }
  288.  
  289. /**
  290.  * Version of |previousSibling| that skips nodes that are entirely
  291.  * whitespace or comments.  (Normally |previousSibling| is a property
  292.  * of all DOM nodes that gives the sibling node, the node that is
  293.  * a child of the same parent, that occurs immediately before the
  294.  * reference node.)
  295.  *
  296.  * @param sib  The reference node.
  297.  * @return     Either:
  298.  *               1) The closest previous sibling to |sib| that is not
  299.  *                  ignorable according to |is_ignorable|, or
  300.  *               2) null if no such node exists.
  301.  */
  302. function node_before( sib )
  303. {
  304.   while ((sib = sib.previousSibling)) {
  305.     if (!is_ignorable(sib)) return sib;
  306.   }
  307.   return null;
  308. }
  309.  
  310. /**
  311.  * Version of |nextSibling| that skips nodes that are entirely
  312.  * whitespace or comments.
  313.  *
  314.  * @param sib  The reference node.
  315.  * @return     Either:
  316.  *               1) The closest next sibling to |sib| that is not
  317.  *                  ignorable according to |is_ignorable|, or
  318.  *               2) null if no such node exists.
  319.  */
  320. function node_after( sib )
  321. {
  322.   while ((sib = sib.nextSibling)) {
  323.     if (!is_ignorable(sib)) return sib;
  324.   }
  325.   return null;
  326. }
  327.  
  328. /**
  329.  * Version of |lastChild| that skips nodes that are entirely
  330.  * whitespace or comments.  (Normally |lastChild| is a property
  331.  * of all DOM nodes that gives the last of the nodes contained
  332.  * directly in the reference node.)
  333.  *
  334.  * @param par  The reference node.
  335.  * @return     Either:
  336.  *               1) The last child of |sib| that is not
  337.  *                  ignorable according to |is_ignorable|, or
  338.  *               2) null if no such node exists.
  339.  */
  340. function last_child( par )
  341. {
  342.   var res=par.lastChild;
  343.   while (res) {
  344.     if (!is_ignorable(res)) return res;
  345.     res = res.previousSibling;
  346.   }
  347.   return null;
  348. }
  349.  
  350. /**
  351.  * Version of |firstChild| that skips nodes that are entirely
  352.  * whitespace and comments.
  353.  *
  354.  * @param par  The reference node.
  355.  * @return     Either:
  356.  *               1) The first child of |sib| that is not
  357.  *                  ignorable according to |is_ignorable|, or
  358.  *               2) null if no such node exists.
  359.  */
  360. function first_child( par )
  361. {
  362.   var res=par.firstChild;
  363.   while (res) {
  364.     if (!is_ignorable(res)) return res;
  365.     res = res.nextSibling;
  366.   }
  367.   return null;
  368. }
  369.  
  370. /**
  371.  * Version of |data| that doesn't include whitespace at the beginning
  372.  * and end and normalizes all whitespace to a single space.  (Normally
  373.  * |data| is a property of text nodes that gives the text of the node.)
  374.  *
  375.  * @param txt  The text node whose data should be returned
  376.  * @return     A string giving the contents of the text node with
  377.  *             whitespace collapsed.
  378.  */
  379. function data_of( txt )
  380. {
  381.   var data = txt.data;
  382.   // Use ECMA-262 Edition 3 String and RegExp features
  383.   data = data.replace(/[\t\n\r ]+/g, " ");
  384.   if (data.charAt(0) == " ")
  385.     data = data.substring(1, data.length);
  386.   if (data.charAt(data.length - 1) == " ")
  387.     data = data.substring(0, data.length - 1);
  388.   return data;
  389. }
  390.  
  391.  
  392. // CLASSES ////////////////////////////////////////////////////////////////////
  393.  
  394. // NextNode: the node next to the statistics node when it is created
  395. function CStat(NextNode)
  396. 	{
  397. 	var NewSection = document.createElement("div");
  398. 	NewSection.id = "stat_all";
  399. 	this._Node = NextNode.parentNode.insertBefore(NewSection, NextNode);
  400.  
  401. 	this._HTML = '';
  402.  
  403. 	this._gInfoList = [];
  404.  
  405. 	this.nTotalPages = 0;
  406. 	this.nReadPages = 0;
  407. 	}
  408.  
  409. CStat.prototype._Write = function(Text) {this._HTML += Text;};
  410.  
  411. CStat.prototype._Flush = function() {this._Node.innerHTML = this._HTML;};
  412.  
  413. CStat.prototype.RegInfoList = function(InfoList)
  414. 	{
  415. 	if (InfoList instanceof CInfoList)
  416. 		{
  417. 		this._gInfoList.push(InfoList);
  418. 		return true;
  419. 		}
  420. 	return false;
  421. 	};
  422.  
  423. CStat.prototype.SaveInfo = function(Info)
  424. 	{
  425. 	for (var i = 0; i < this._gInfoList.length; ++i)
  426. 		this._gInfoList[i].SaveInfo(Info);
  427. 	};
  428.  
  429. CStat.prototype.Show = function()
  430. 	{
  431. 	this._Write("<hr />");
  432. 	for (var i = 0; i < this._gInfoList.length; ++i)
  433. 		this._Write( this._gInfoList[i].Show() );
  434. 	this._Write(this._OptionsHTML());
  435. 	this._Write("<hr />");
  436. 	this._Flush();
  437.  
  438. 	for (var i = 0; i < this._gInfoList.length; ++i)
  439. 		this._gInfoList[i].AddEvents();
  440. 	this._AddEvents();
  441. 	};
  442.  
  443. CStat.prototype.ShowProgress = function()
  444. 	{
  445. 	this._Node.innerHTML = '<hr /><h1>' + Local.Text_Loading + ' (' +
  446. 		this.nReadPages + '/' + this.nTotalPages + ') ...</h1><hr />';
  447. 	};
  448.  
  449. CStat.prototype._OptionsHTML = function()
  450. 	{
  451. 	var Str = '<div id="stat_options">' +
  452. 		'<div class="stat_header"><span class="stat_title">' + Local.Text_Options + '</span>';
  453. 	Str += CreateElementHTML("input", null, ["type", "button"], ["class", "button"],
  454. 		["id", "stat_options_default"], ["value", Local.Text_Button_Default]);
  455. 	Str += '</div></div>';
  456. 	return Str;
  457. 	};
  458.  
  459. CStat.prototype._AddEvents = function()
  460. 	{
  461. 	function OnDelGMValues()
  462. 		{
  463. 		try	{
  464. 			var ValueList = GM_listValues();
  465. 			for (var name in ValueList) {GM_deleteValue(ValueList[name]);}
  466. 			alert(Local.Text_DefaultMsg);
  467. 			}
  468. 		catch (e) {alert("OnDelGMValues(): " + e);}
  469. 		}
  470. 	$("stat_options_default").addEventListener("click", OnDelGMValues, false);
  471. 	};
  472.  
  473.  
  474. ///////////////////////////////////////////////////////////////////////////////
  475. function CTable(Title, Id, nColumns)
  476. 	{
  477. 	this._Title = Title;
  478. 	this._Id = Id;
  479. 	this._nColumns = nColumns;
  480. 	this._HeadCellContents = new Array(nColumns);
  481. 	this._BodyCellContentTypes = new Array(nColumns);
  482. 	this._BodyCellContents = [];
  483. 	this._HTML = '';
  484.  
  485. 	this._bShow = GM_getValue(Id, true);
  486. 	}
  487.  
  488. CTable._ContentAttrs = {
  489. 		string	: '',
  490. 		number	: 'align="right"',
  491. 		button	: 'align="center"'};
  492.  
  493. CTable.prototype.SetHeadCellContents = function(/* Content1, Content2, ... */)
  494. 	{
  495. 	for (var i = 0; i < this._nColumns; ++i)
  496. 		this._HeadCellContents[i] = arguments[i] != null ? arguments[i] : "";
  497. 	};
  498.  
  499. // Type: a string that is the property name of CTable::ContentAttrs
  500. CTable.prototype.SetBodyCellContentTypes = function(/* Type1, Type2, ... */)
  501. 	{
  502. 	for (var i = 0; i < this._nColumns; ++i)
  503. 		this._BodyCellContentTypes[i] =
  504. 			arguments[i] != null ? CTable._ContentAttrs[arguments[i]] : "";
  505. 	};
  506.  
  507. CTable.prototype.SetBodyCellContents = function(/* Content1, Content2, ... */)
  508. 	{
  509. 	var Contents = new Array(this._nColumns);
  510. 	for (var i = 0; i < this._nColumns; ++i)
  511. 		Contents[i] = arguments[i] != null ? arguments[i] : "";
  512. 	this._BodyCellContents.push(Contents);
  513. 	};
  514.  
  515. CTable.prototype.CreateHTML = function()
  516. 	{
  517. 	this._HTML = '<div id="' + this._Id + '">' +
  518. 		'<div class="stat_header"><span class="stat_title clickable">' + this._Title + '</span></div>' +
  519. 		'<table class="content_table" ' + (this._bShow ? '' : 'hide="hide"') + '>' +
  520. 		'<tr class="content_table_header">';
  521.  
  522. 	for (var i = 0; i < this._nColumns; ++i)
  523. 		this._HTML += '<th class="content_table">' + this._HeadCellContents[i] + '</th>';
  524. 	this._HTML += '</tr>';
  525. 	
  526. 	for (var i = 0; i < this._BodyCellContents.length; ++i)
  527. 		{
  528. 		this._HTML += '<tr class="content_table_row_' + i % 2 + '">';
  529. 		for (var j = 0; j < this._nColumns; ++j)
  530. 			{
  531. 			this._HTML += '<td class="content_table" ' +
  532. 				this._BodyCellContentTypes[j] + '>' +
  533. 				this._BodyCellContents[i][j] + '</td>';
  534. 			}
  535. 		this._HTML += '</tr>';
  536. 		}
  537. 	this._HTML += '</table></div>';
  538.  
  539. 	return this._HTML;
  540. 	};
  541.  
  542. CTable.prototype.GetHTML = function()
  543. 	{return this._HTML;};
  544.  
  545. CTable.prototype.AddEvents = function()
  546. 	{
  547. 	var Title = $(this._Id).getElementsByTagName("span")[0];
  548. 	function Factory(Id) {return function(){CTable.OnClickTitle(Id);};}
  549. 	Title.addEventListener("click", Factory(this._Id), false);
  550. 	};
  551.  
  552. CTable.OnClickTitle = function(Id)
  553. 	{
  554. 	try	{
  555. 		var Table = $(Id).getElementsByTagName("table")[0];
  556. 		if (Table.hasAttribute("hide"))
  557. 			{
  558. 			Table.removeAttribute("hide");
  559. 			GM_setValue(Id, true);
  560. 			}
  561. 		else
  562. 			{
  563. 			Table.setAttribute("hide", "hide");
  564. 			GM_setValue(Id, false);
  565. 			}
  566. 		}
  567. 	catch (e) {alert("CTable.OnClickTitle(): " + e);}
  568. 	};
  569.  
  570.  
  571. ///////////////////////////////////////////////////////////////////////////////
  572. function CActiveInfo()
  573. 	{
  574. 	this.nIniRoll;
  575. 	this.nCurrAction;
  576. 	this.nTotalActions;
  577. 	this.Char		= new CChar();
  578. 	this.nCharId;
  579. 	this.ActionType		= new CActionType();
  580. 	this.Skill		= new CSkill();
  581. 	this.nAttackRoll;
  582. 	this.nSkillMP;
  583. 	this.gItem		= new CKeyList();
  584. 	}
  585.  
  586.  
  587. function CPassiveInfo()
  588. 	{
  589. 	this.Char		= new CChar();
  590. 	this.nCharId;
  591. 	this.Skill		= new CSkill();
  592. 	this.nDefenceRoll;
  593. 	this.nSkillMP;
  594. 	this.gItem		= new CKeyList();
  595. 	this.HitType		= new CHitType();
  596. 	this.bStruckDown;
  597. 	this.gDamage		= [];
  598. 	this.DamagedItem	= new CItem();
  599. 	this.nItemDamage;
  600. 	this.nHealedHP;
  601. 	this.nHealedMP;
  602. 	}
  603.  
  604.  
  605. function CNavi(nLevel, nRoom, nRound, nRow)
  606. 	{
  607. 	this.nLevel		= nLevel;
  608. 	this.nRoom		= nRoom;
  609. 	this.nRound		= nRound;
  610. 	this.nRow		= nRow;
  611. 	}
  612.  
  613.  
  614. function CActionInfo(Navi)
  615. 	{
  616. 	this.Navi		= Navi;
  617. 	this.Active		= new CActiveInfo();
  618. 	this.gPassive		= [];
  619. 	}
  620.  
  621.  
  622. ///////////////////////////////////////////////////////////////////////////////
  623. // Class: Key
  624. // Every key should have two function properties: compareTo() and toString(),
  625. //   and can work without initialization parameters
  626.  
  627. var CKey = DefineClass({
  628. 	methods:
  629. 		{
  630. 		compareTo: function(that) {return this - that;},
  631. 		toString: function() {return "";}
  632. 		}
  633. 	});
  634.  
  635.  
  636. var CKeyList = DefineClass({
  637. 	extend: CKey,
  638. 	construct: function() {this._gKey = [];},
  639. 	methods:
  640. 		{
  641. 		push: function(Key) {return this._gKey.push(Key);},
  642. 		compareTo: function(that)
  643. 			{
  644. 			var result = this._gKey.length - that._gKey.length;
  645. 			if (result !== 0)
  646. 				return result;
  647.  
  648. 			var i = 0;
  649. 			while (i < this._gKey.length && this._gKey[i].compareTo(that._gKey[i]) === 0)
  650. 				++i;
  651. 			if (i === this._gKey.length)
  652. 				return 0;
  653. 			else
  654. 				return this._gKey[i].compareTo(that._gKey[i]);
  655. 			},
  656. 		toString: function() {return this._gKey.join(", ");}
  657. 		}
  658. 	});
  659.  
  660.  
  661. var CChar = DefineClass({
  662. 	extend: CKey,
  663. 	construct: function(HTMLElement)
  664. 		{
  665. 		this._Name;
  666. 		this._Href;
  667. 		this._OnClick;
  668. 		this._Class;
  669. 		this._nType;
  670.  
  671. 		if (HTMLElement != null)
  672. 			{
  673. 			this._Name = HTMLElement.firstChild.data;
  674. 			this._Href = HTMLElement.getAttribute("href");
  675. 			this._OnClick = HTMLElement.getAttribute("onclick");
  676. 			this._Class = HTMLElement.className;
  677. 			this._nType = CChar._GetCharType(this._Class);
  678. 			if (this._nType === null)
  679. 				DbgMsg("CChar(): Unknown type: " + this._Class);
  680. 			}
  681. 		},
  682. 	methods:
  683. 		{
  684. 		GetType: function() {return this._nType;},
  685. 		compareTo: function(that)
  686. 			{
  687. 			var result = this._nType - that._nType;
  688. 			if (result !== 0)
  689. 				return result;
  690. 			return CompareString(this._Name, that._Name);
  691. 			},
  692. 		toString: function()
  693. 			{
  694. 			if (this._Name != null)
  695. 				return CreateElementHTML("a", this._Name, ["href", this._Href],
  696. 					["onclick", this._OnClick], ["class", this._Class]);
  697. 			else
  698. 				return "";
  699. 			}
  700. 		},
  701. 	statics:
  702. 		{
  703. 		_GetCharType: function(Class)
  704. 			{
  705. 			switch (Class)
  706. 				{
  707. 				case "rep_hero":
  708. 				case "rep_myhero":
  709. 					return 0;
  710. 				case "rep_monster":
  711. 				case "rep_myhero_defender":
  712. 					return 1;
  713. 				default:
  714. 					return null;
  715. 				}
  716. 			}
  717. 		}
  718. 	});
  719.  
  720.  
  721. // In-round actions
  722. var CActionType = DefineClass({
  723. 	extend: CKey,
  724. 	construct: function(ActionText)
  725. 		{
  726. 		this._nType;
  727. 		this._nKind;
  728.  
  729. 		if (ActionText != null)
  730. 			{
  731. 			var ret = CActionType._GetActionTypeAndKind(ActionText);
  732. 			this._nType = ret[0];
  733. 			this._nKind = ret[1];
  734. 			}
  735. 		},
  736. 	methods:
  737. 		{
  738. 		GetType: function() {return this._nType;},
  739. 		GetKind: function() {return this._nKind;},
  740. 		compareTo: function(that) {return this._nType - that._nType;},
  741. 		toString: function()
  742. 			{
  743. 			switch (this._nKind)
  744. 				{
  745. 				case 0:		return Local.TextList_AttackType[this._nType];
  746. 				case 1:		return "heal";
  747. 				case 2:		return "buff";
  748. 				case 3:		return "wait";
  749. 				default:	return "unknown";
  750. 				}
  751. 			}
  752. 		},
  753. 	statics:
  754. 		{
  755. 		// return: an array, [0]: _nType, [1]: _nKind
  756. 		_GetActionTypeAndKind: function(ActionText)
  757. 			{
  758. 			switch (ActionText)
  759. 				{
  760. 				case Local.OrigTextList_ActionType[0]:	// melee
  761. 					return [0, 0];
  762. 				case Local.OrigTextList_ActionType[1]:	// ranged
  763. 					return [1, 0];
  764. 				case Local.OrigTextList_ActionType[2]:	// magic
  765. 					return [2, 0];
  766. 				case Local.OrigTextList_ActionType[3]:	// social
  767. 					return [3, 0];
  768. 				case Local.OrigTextList_ActionType[4]:	// ambush
  769. 					return [4, 0];
  770. 				case Local.OrigTextList_ActionType[5]:	// trap
  771. 					return [5, 0];
  772. 				case Local.OrigTextList_ActionType[6]:	// nature
  773. 					return [6, 0];
  774. 				case Local.OrigTextList_ActionType[7]:	// disease
  775. 					return [7, 0];
  776. 				case Local.OrigTextList_ActionType[8]:	// detonate
  777. 					return [8, 0];
  778. 				case Local.OrigTextList_ActionType[9]:	// disarm trap
  779. 					return [9, 0];
  780. 				case Local.OrigTextList_ActionType[10]:	// magic projectile
  781. 					return [10, 0];
  782. 				case Local.OrigTextList_ActionType[11]:	// curse
  783. 					return [11, 0];
  784. 				case Local.OrigTextList_ActionType[12]:	// scare
  785. 					return [12, 0];
  786. 				case Local.OrigTextList_ActionType[13]:	// heal
  787. 					return [13, 1];
  788. 				case Local.OrigTextList_ActionType[14]:	// buff
  789. 					return [14, 2];
  790. 				case Local.OrigTextList_ActionType[15]:	// summon
  791. 					return [15, 2];
  792. 				case Local.OrigTextList_ActionType[16]:	// do nothing
  793. 					return [16, 3];
  794. 				case Local.OrigTextList_ActionType[17]:	// wait
  795. 					return [17, 3];
  796. 				default:
  797. 					return [null, null];
  798. 				}
  799. 			}
  800. 		}
  801. 	});
  802.  
  803.  
  804. var CSkill = DefineClass({
  805. 	extend: CKey,
  806. 	construct: function(HTMLElement)
  807. 		{
  808. 		this._Name;
  809. 		this._Href;
  810. 		this._OnClick;
  811.  
  812. 		if (HTMLElement != null)
  813. 			{
  814. 			this._Name = HTMLElement.firstChild.data;
  815. 			this._Href = HTMLElement.getAttribute("href");
  816. 			this._OnClick = HTMLElement.getAttribute("onclick");
  817. 			}
  818. 		},
  819. 	methods:
  820. 		{
  821. 		compareTo: function(that) {return CompareString(this._Name, that._Name);},
  822. 		toString: function()
  823. 			{
  824. 			if (this._Name != null)
  825. 				return CreateElementHTML("a", this._Name, ["href", this._Href],
  826. 					["onclick", this._OnClick]);
  827. 			else
  828. 				return "";
  829. 			}
  830. 		}
  831. 	});
  832.  
  833.  
  834. var CItem = DefineClass({
  835. 	extend: CKey,
  836. 	construct: function(HTMLElement)
  837. 		{
  838. 		this._Name;
  839. 		this._Href;
  840. 		this._OnClick;
  841. 		this._Class;
  842.  
  843. 		if (HTMLElement != null)
  844. 			{
  845. 			this._Name = HTMLElement.firstChild.data;
  846. 			this._Href = HTMLElement.getAttribute("href");
  847. 			this._OnClick = HTMLElement.getAttribute("onclick");
  848. 			this._Class = HTMLElement.className;
  849. 			}
  850. 		},
  851. 	methods:
  852. 		{
  853. 		compareTo: function(that) {return CompareString(this._Name, that._Name);},
  854. 		toString: function()
  855. 			{
  856. 			if (this._Name != null)
  857. 				return CreateElementHTML("a", this._Name, ["href", this._Href],
  858. 					["onclick", this._OnClick], ["class", this._Class]);
  859. 			else
  860. 				return "";
  861. 			}
  862. 		}
  863. 	});
  864.  
  865.  
  866. var CHitType = DefineClass({
  867. 	extend: CKey,
  868. 	construct: function(HitClassText)
  869. 		{
  870. 		this._nType;
  871.  
  872. 		if (HitClassText != null)
  873. 			{
  874. 			this._nType = CHitType._GetHitType(HitClassText);
  875. 			if (this._nType === null)
  876. 				DbgMsg("CHitType(): Unknown type: " + HitClassText);
  877. 			}
  878. 		},
  879. 	methods:
  880. 		{
  881. 		GetType: function() {return this._nType;},
  882. 		compareTo: function(that) {return this._nType - that._nType;},
  883. 		toString: function()
  884. 			{
  885. 			if (this._nType != null)
  886. 				return Local.TextList_HitType[this._nType];
  887. 			else
  888. 				return "";
  889. 			}
  890. 		},
  891. 	statics:
  892. 		{
  893. 		_GetHitType: function(Class)
  894. 			{
  895. 			switch (Class)
  896. 				{
  897. 				case "rep_miss":
  898. 					return 0;
  899. 				case "rep_hit":
  900. 					return 1;
  901. 				case "rep_hit_good":
  902. 					return 2;
  903. 				case "rep_hit_crit":
  904. 					return 3;
  905. 				default:
  906. 					return null;
  907. 				}
  908. 			}
  909. 		}
  910. 	});
  911.  
  912.  
  913. var CDamage = DefineClass({
  914. 	extend: CKey,
  915. 	construct: function(HTMLElement)
  916. 		{
  917. 		this._nBasicDmg;
  918. 		this._nActualDmg;
  919. 		this._nArmor;
  920. 		this._nType;
  921.  
  922. 		if (HTMLElement != null)
  923. 			{
  924. 			var Str;
  925. 			if (HTMLElement.nodeType != 3)
  926. 				{
  927. 				Str = HTMLElement.getAttribute("onmouseover");
  928. 				// \1	basic damage
  929. 				var Patt_BasicDamage = Local.Pattern_BasicDamage;
  930. 				var result = Patt_BasicDamage.exec(Str);
  931. 				if (result == null)
  932. 					throw "CDamage() :" + Str;
  933. 				this._nBasicDmg = Number(result[1]);
  934. 				Str = HTMLElement.firstChild.data;
  935. 				}
  936. 			else
  937. 				Str = HTMLElement.data;
  938.  
  939. 			// \1	actual damage
  940. 			// \2	armor
  941. 			// \3	damage type
  942. 			var Patt_Damage = Local.Pattern_Damage;
  943. 			var result = Patt_Damage.exec(Str);
  944. 			if (result == null)
  945. 				throw "CDamage() :" + Str;
  946. 			this._nActualDmg = Number(result[1]);
  947. 			this._nArmor = result[2] != null ? Number(result[2]) : 0;
  948. 			this._nType = CDamage._GetDamageType(result[3]);
  949.  
  950. 			if (this._nType === null)
  951. 				DbgMsg("CDamage(): Unknown type: " + result[3]);
  952. 			if (this._nBasicDmg == null)
  953. 				this._nBasicDmg = this._nActualDmg + this._nArmor;
  954. 			}
  955. 		},
  956. 	methods:
  957. 		{
  958. 		GetType:	function() {return this._nType;},
  959. 		GetBasicDmg:	function() {return this._nBasicDmg;},
  960. 		GetArmor:	function() {return this._nArmor;},
  961. 		GetActualDmg:	function() {return this._nActualDmg;},
  962. 		IsHPDamage:	function() {return this._nType !== 11;},
  963. 		compareTo: function(that) {return this._nBasicDmg - that._nBasicDmg;},
  964. 		toString: function()
  965. 			{
  966. 			if (this._nType != null)
  967. 				{
  968. 				var Str = String(this._nBasicDmg);
  969. 				if (this._nArmor > 0)
  970. 					Str += " - " + this._nArmor + " -> " + this._nActualDmg;
  971. 				else if (this._nBasicDmg !== this._nActualDmg)
  972. 					Str += " -> " + this._nActualDmg;
  973. 				Str += " " + Local.OrigTextList_DamageType[this._nType] + " damage";
  974. 				return Str;
  975. 				}
  976. 			else
  977. 				return "";
  978. 			}
  979. 		},
  980. 	statics:
  981. 		{
  982. 		_GetDamageType: function(Text)
  983. 			{
  984. 			switch (Text)
  985. 				{
  986. 				case Local.OrigTextList_DamageType[0]:	// crushing
  987. 					return 0;
  988. 				case Local.OrigTextList_DamageType[1]:	// cutting
  989. 					return 1;
  990. 				case Local.OrigTextList_DamageType[2]:	// piercing
  991. 					return 2;
  992. 				case Local.OrigTextList_DamageType[3]:	// fire
  993. 					return 3;
  994. 				case Local.OrigTextList_DamageType[4]:	// ice
  995. 					return 4;
  996. 				case Local.OrigTextList_DamageType[5]:	// lightning
  997. 					return 5;
  998. 				case Local.OrigTextList_DamageType[6]:	// poison
  999. 					return 6;
  1000. 				case Local.OrigTextList_DamageType[7]:	// acid
  1001. 					return 7;
  1002. 				case Local.OrigTextList_DamageType[8]:	// psychological
  1003. 					return 8;
  1004. 				case Local.OrigTextList_DamageType[9]:	// holy
  1005. 					return 9;
  1006. 				case Local.OrigTextList_DamageType[10]:	// disarm trap
  1007. 					return 10;
  1008. 				case Local.OrigTextList_DamageType[11]:	// mana
  1009. 					return 11;
  1010. 				default:
  1011. 					return null;
  1012. 				}
  1013. 			}
  1014. 		}
  1015. 	});
  1016.  
  1017.  
  1018. ///////////////////////////////////////////////////////////////////////////////
  1019. // Class: Value list
  1020. // Value list is a special key, it can contains any type of values, including keys
  1021.  
  1022. var CValueList = DefineClass({
  1023. 	extend: CKey,
  1024. 	construct: function()
  1025. 		{
  1026. 		this._gValue = [];
  1027. 		this._nAvgValue;	// unsure type 
  1028. 		},
  1029. 	methods:
  1030. 		{
  1031. 		GetLength: function() {return this._gValue.length;},
  1032. 		Calculate: function() {},
  1033. 		push: function(Value) {return this._gValue.push(Value);},
  1034. 		compareTo: function(that) {return this._nAvgValue - that._nAvgValue;},
  1035. 		AvgValueStr: function() {return String(this._nAvgValue);},
  1036. 		toString: function() {return this._gValue.join(", ");}
  1037. 		}
  1038. 	});
  1039.  
  1040.  
  1041. var CVLNumber = DefineClass({
  1042. 	extend: CValueList,
  1043. 	construct: function() {this.superclass();},
  1044. 	methods:
  1045. 		{
  1046. 		Calculate: function()
  1047. 			{
  1048. 			var nTotalValue = 0;
  1049. 			for (var i = 0; i < this._gValue.length; ++i)
  1050. 				nTotalValue += this._gValue[i];
  1051. 			this._nAvgValue = Number((nTotalValue / this._gValue.length).toFixed(2));
  1052. 			}
  1053. 		}
  1054. 	});
  1055.  
  1056.  
  1057. // value: [Number1, Number2]
  1058. var CVLPairNumber = DefineClass({
  1059. 	extend: CValueList,
  1060. 	construct: function() {this.superclass();},
  1061. 	methods:
  1062. 		{
  1063. 		Calculate: function()
  1064. 			{
  1065. 			var nTotalValue = [0, 0];
  1066. 			for (var i = 0; i < this._gValue.length; ++i)
  1067. 				{
  1068. 				nTotalValue[0] += this._gValue[i][0];
  1069. 				nTotalValue[1] += this._gValue[i][1];
  1070. 				}
  1071. 			this._nAvgValue = new Array(2);
  1072. 			this._nAvgValue[0] = Number((nTotalValue[0] / this._gValue.length).toFixed(2));
  1073. 			this._nAvgValue[1] = Number((nTotalValue[1] / this._gValue.length).toFixed(2));
  1074. 			},
  1075. 		compareTo: function(that)
  1076. 			{
  1077. 			if (this._nAvgValue[0] !== 0 || that._nAvgValue[0] !== 0)
  1078. 				return this._nAvgValue[0] - that._nAvgValue[0];
  1079. 			else
  1080. 				return this._nAvgValue[1] - that._nAvgValue[1];
  1081. 			},
  1082. 		AvgValueStr: function()
  1083. 			{
  1084. 			return '<table class="pair_value"><tr><td>' +
  1085. 				((this._nAvgValue[0] !== 0) ? String(this._nAvgValue[0]) : '') +
  1086. 				'</td><td>' +
  1087. 				((this._nAvgValue[1] !== 0) ? String(this._nAvgValue[1]) : '') +
  1088. 				'</td></tr></table>';
  1089. 			},
  1090. 		toString: function()
  1091. 			{
  1092. 			var Str = "";
  1093. 			for (var i = 0; i < this._gValue.length; ++i)
  1094. 				{
  1095. 				Str += (this._gValue[i][0] != null) ? this._gValue[i][0] : 0;
  1096. 				Str += "/";
  1097. 				Str += (this._gValue[i][1] != null) ? this._gValue[i][1] : 0;
  1098. 				if (i < this._gValue.length -1)
  1099. 					Str += ", ";
  1100. 				}
  1101. 			return Str;
  1102. 			}
  1103. 		}
  1104. 	});
  1105.  
  1106.  
  1107. // value: An Array of CDamage
  1108. var CVLDamage = DefineClass({
  1109. 	extend: CValueList,
  1110. 	construct: function() {this.superclass();},
  1111. 	methods:
  1112. 		{
  1113. 		Calculate: function()
  1114. 			{
  1115. 			var nTotalValue = [0, 0];
  1116. 			for (var i = 0; i < this._gValue.length; ++i)
  1117. 				{
  1118. 				for (var j = 0; j < this._gValue[i].length; ++j)
  1119. 					{
  1120. 					if (this._gValue[i][j].IsHPDamage())
  1121. 						{
  1122. 						nTotalValue[0] += this._gValue[i][j].GetBasicDmg();
  1123. 						nTotalValue[1] += this._gValue[i][j].GetActualDmg();
  1124. 						}
  1125. 					}
  1126. 				}
  1127. 			this._nAvgValue = new Array(2);
  1128. 			this._nAvgValue[0] = Number((nTotalValue[0] / this._gValue.length).toFixed(2));
  1129. 			this._nAvgValue[1] = Number((nTotalValue[1] / this._gValue.length).toFixed(2));
  1130. 			},
  1131. 		compareTo: function(that) {return this._nAvgValue[1] - that._nAvgValue[1];},
  1132. 		AvgValueStr: function()
  1133. 			{
  1134. 			return '<table class="pair_value"><tr><td>' +
  1135. 				this._nAvgValue[1] + '</td><td>' +
  1136. 				this._nAvgValue[0] + '</td></tr></table>';
  1137. 			},
  1138. 		toString: function()
  1139. 			{
  1140. 			var Str = "";
  1141. 			for (var i = 0; i < this._gValue.length; ++i)
  1142. 				{
  1143. 				var nTotalValue = [0, 0];
  1144. 				for (var j = 0; j < this._gValue[i].length; ++j)
  1145. 					{
  1146. 					if (this._gValue[i][j].IsHPDamage())
  1147. 						{
  1148. 						nTotalValue[0] += this._gValue[i][j].GetBasicDmg();
  1149. 						nTotalValue[1] += this._gValue[i][j].GetActualDmg();
  1150. 						}
  1151. 					}
  1152. 				Str += nTotalValue[1] + "/" + nTotalValue[0];
  1153. 				if (i < this._gValue.length -1)
  1154. 					Str += ", ";
  1155. 				}
  1156. 			return Str;
  1157. 			}
  1158. 		}
  1159. 	});
  1160.  
  1161.  
  1162. ///////////////////////////////////////////////////////////////////////////////
  1163. // Class: Info list
  1164.  
  1165. var CInfoList = DefineClass({
  1166. 	construct: function(nKeys, CValueList)
  1167. 		{
  1168. 		this._gInfo		= [];
  1169. 		this._nKeys		= nKeys;
  1170. 		this._CValueList	= CValueList;
  1171. 		this._Table		= null;
  1172. 		},
  1173. 	methods:
  1174. 		{
  1175. 		_CompareKeys: function(gKeyA, gKeyB)
  1176. 			{
  1177. 			for (var i = 0; i < this._nKeys; ++i)
  1178. 				{
  1179. 				var result = gKeyA[i].compareTo( gKeyB[i] );
  1180. 				if (result !== 0)
  1181. 					return result;
  1182. 				}
  1183. 			return 0;
  1184. 			},
  1185. 		_SetTableBodyCellContents: function()
  1186. 			{
  1187. 			for (var i = 0; i < this._gInfo.length; ++i)
  1188. 				{
  1189. 				var gBodyCellContent = [];
  1190. 				for (var j = 0; j < this._gInfo[i].gKey.length; ++j)
  1191. 					gBodyCellContent.push( this._gInfo[i].gKey[j] );
  1192.  
  1193. 				gBodyCellContent.push( this._gInfo[i].ValueList.AvgValueStr(),
  1194. 					String(this._gInfo[i].ValueList.GetLength()),
  1195. 					CreateElementHTML("input", null, ["type", "button"],
  1196. 						["class", "button"], ["value", Local.Text_Button_Show],
  1197. 						["onclick", 'alert(&quot;' + this._gInfo[i].ValueList.toString() + '&quot;);']) );
  1198.  
  1199. 				this._Table.SetBodyCellContents.apply(this._Table, gBodyCellContent);
  1200. 				}
  1201. 			},
  1202. 		SaveInfo: function(Info) {},
  1203. 		Show: function() {},
  1204. 		// Call this function when read all data, and before sort and export data
  1205. 		CalculateValue: function()
  1206. 			{
  1207. 			for (var i = 0; i < this._gInfo.length; ++i)
  1208. 				this._gInfo[i].ValueList.Calculate();
  1209. 			},
  1210. 		CreateTable: function(Title, Id, gKeyName)
  1211. 			{
  1212. 			// Key1, Key2, ..., AverageValue, Times, ValueList
  1213. 			this._Table = new CTable(Title, Id, this._nKeys + 3);
  1214.  
  1215. 			var gHeadCellContent = new Array(this._nKeys + 3);
  1216. 			for (var i = 0; i < this._nKeys; ++i)
  1217. 				gHeadCellContent[i] = gKeyName[i];
  1218. 			gHeadCellContent[this._nKeys] = Local.Text_Table_AvgRoll;
  1219. 			gHeadCellContent[this._nKeys + 1] = Local.Text_Table_Times;
  1220. 			gHeadCellContent[this._nKeys + 2] = Local.Text_Table_RollList;
  1221. 			this._Table.SetHeadCellContents.apply(this._Table, gHeadCellContent);
  1222.  
  1223. 			var gBodyCellContentType = new Array(this._nKeys + 3);
  1224. 			for (var i = 0; i < this._nKeys; ++i)
  1225. 				gBodyCellContentType[i] = "string";
  1226. 			gBodyCellContentType[this._nKeys] = "number";
  1227. 			gBodyCellContentType[this._nKeys + 1] = "number";
  1228. 			gBodyCellContentType[this._nKeys + 2] = "button";
  1229. 			this._Table.SetBodyCellContentTypes.apply(this._Table, gBodyCellContentType);
  1230.  
  1231. 			this._SetTableBodyCellContents();
  1232.  
  1233. 			return this._Table.CreateHTML();
  1234. 			},
  1235. 		// Call this function when edited the info list (for example, re-sorted it)
  1236. 		ReCreateTableHTML: function()
  1237. 			{
  1238. 			this._SetTableBodyCellContents();
  1239. 			return this._Table.CreateHTML();
  1240. 			},
  1241. 		GetTableHTML: function() {return this._Table.GetHTML();},
  1242. 		AddEvents: function() {if (this._Table != null) this._Table.AddEvents();},
  1243. 		push: function(gKey, Value)
  1244. 			{
  1245. 			for (var i = 0; i < this._gInfo.length; ++i)
  1246. 				{
  1247. 				if (this._CompareKeys(this._gInfo[i].gKey, gKey) === 0)
  1248. 					{
  1249. 					this._gInfo[i].ValueList.push(Value);
  1250. 					return this._gInfo.length;
  1251. 					}
  1252. 				}
  1253.  
  1254. 			var ValueList = new this._CValueList();
  1255. 			ValueList.push(Value);
  1256. 			return this._gInfo.push(new CInfoList._CInfo(gKey, ValueList));
  1257. 			},
  1258. 		sort: function(gSortKeyId)
  1259. 			{
  1260. 			function Factory(gId) {return function(A, B){return CInfoList._CompareInfo(A, B, gId);};}
  1261. 			return this._gInfo.sort(Factory(gSortKeyId));
  1262. 			}
  1263. 		},
  1264. 	statics:
  1265. 		{
  1266. 		_CInfo: function(gKey, ValueList)
  1267. 			{
  1268. 			this.gKey = gKey;
  1269. 			this.ValueList = ValueList;
  1270. 			},
  1271. 		// SortKeyId: Id of keys, or null
  1272. 		// The list will be sorted in this way: sort them by the first key, if there are
  1273. 		//   elements are still equal, then sort them by the second key, and so on.
  1274. 		// If SortKeyId is null, then sort the list by value
  1275. 		// If gSortKeyId is null, then sort the list by default order of keys
  1276. 		_CompareInfo: function(InfoA, InfoB, gSortKeyId)
  1277. 			{
  1278. 			if (gSortKeyId == null)
  1279. 				{
  1280. 				for (var i = 0; i < InfoA.gKey.length; ++i)
  1281. 					{
  1282. 					var result = InfoA.gKey[i].compareTo(InfoB.gKey[i]);
  1283. 					if (result !== 0) return result;
  1284. 					}
  1285. 				return 0;
  1286. 				}
  1287. 			else
  1288. 				{
  1289. 				for (var i = 0; i < gSortKeyId.length; ++i)
  1290. 					{
  1291. 					var KeyId = gSortKeyId[i];
  1292. 					var result = (KeyId != null) ?
  1293. 						InfoA.gKey[KeyId].compareTo(InfoB.gKey[KeyId]) :
  1294. 						InfoA.ValueList.compareTo(InfoB.ValueList);
  1295. 					if (result !== 0) return result;
  1296. 					}
  1297. 				return 0;
  1298. 				}
  1299. 			}
  1300. 		}
  1301. 	});
  1302.  
  1303.  
  1304. ///////////////////////////////////////////////////////////////////////////////
  1305. // Sub classes of CInfoList
  1306. //
  1307. // var CIL_ = DefineClass({
  1308. //	extend: CInfoList,
  1309. //	construct: function(_nKeys, CValueList) {this.superclass(_nKeys, CValueList);},
  1310. //	methods:
  1311. //		{
  1312. //		_SetTableBodyCellContents: function() {},
  1313. //		SaveInfo: function(Info) {},
  1314. //		Show: function() {},
  1315. //		CreateTable: function(Title, Id, gKeyName) {}
  1316. //		}
  1317. //	});
  1318.  
  1319. var CILIni = DefineClass({
  1320. 	extend: CInfoList,
  1321. 	construct: function(nKeys, CValueList) {this.superclass(nKeys, CValueList);},
  1322. 	methods:
  1323. 		{
  1324. 		SaveInfo: function(Info)
  1325. 			{
  1326. 			if (Info.Active.nCurrAction === 1)
  1327. 				this.push([Info.Active.Char], Info.Active.nIniRoll);
  1328. 			},
  1329. 		Show: function()
  1330. 			{
  1331. 			if (this._gInfo.length > 0)
  1332. 				{
  1333. 				this.CalculateValue();
  1334. 				this.sort();
  1335. 				return this.CreateTable(Local.Text_Table_Ini, "stat_ini", [Local.Text_Table_Char]);
  1336. 				}
  1337. 			return "";
  1338. 			}
  1339. 		}
  1340. 	});
  1341.  
  1342.  
  1343. var CILAttackRoll = DefineClass({
  1344. 	extend: CInfoList,
  1345. 	construct: function(nKeys, CValueList) {this.superclass(nKeys, CValueList);},
  1346. 	methods:
  1347. 		{
  1348. 		SaveInfo: function(Info)
  1349. 			{
  1350. 			if (Info.Active.ActionType.GetKind() === 0 && Info.Active.nAttackRoll != null)
  1351. 				this.push([Info.Active.Char, Info.Active.ActionType, Info.Active.Skill, Info.Active.gItem],
  1352. 					Info.Active.nAttackRoll);
  1353. 			},
  1354. 		Show: function()
  1355. 			{
  1356. 			if (this._gInfo.length > 0)
  1357. 				{
  1358. 				this.CalculateValue();
  1359. 				this.sort();
  1360. 				return this.CreateTable( Local.Text_Table_Attack, "stat_attack",
  1361. 					[Local.Text_Table_Char, Local.Text_Table_AttackType, Local.Text_Table_Skill, Local.Text_Table_Item]);
  1362. 				}
  1363. 			return "";
  1364. 			}
  1365. 		}
  1366. 	});
  1367.  
  1368.  
  1369. var CILDefenceRoll = DefineClass({
  1370. 	extend: CInfoList,
  1371. 	construct: function(nKeys, CValueList) {this.superclass(nKeys, CValueList);},
  1372. 	methods:
  1373. 		{
  1374. 		SaveInfo: function(Info)
  1375. 			{
  1376. 			if (Info.Active.ActionType.GetKind() === 0)
  1377. 				{
  1378. 				for (var i = 0; i < Info.gPassive.length; ++i)
  1379. 					{
  1380. 					if (Info.gPassive[i].nDefenceRoll != null)
  1381. 						this.push([Info.gPassive[i].Char, Info.Active.ActionType,
  1382. 							Info.gPassive[i].Skill, Info.gPassive[i].gItem], Info.gPassive[i].nDefenceRoll);
  1383. 					}
  1384. 				}
  1385. 			},
  1386. 		Show: function()
  1387. 			{
  1388. 			if (this._gInfo.length > 0)
  1389. 				{
  1390. 				this.CalculateValue();
  1391. 				this.sort();
  1392. 				return this.CreateTable(Local.Text_Table_Defence, "stat_defence",
  1393. 					[Local.Text_Table_Char, Local.Text_Table_DefenceType, Local.Text_Table_Skill, Local.Text_Table_Item]);
  1394. 				}
  1395. 			return "";
  1396. 			}
  1397. 		}
  1398. 	});
  1399.  
  1400.  
  1401. var CILDamage = DefineClass({
  1402. 	extend: CInfoList,
  1403. 	construct: function(nKeys, CValueList) {this.superclass(nKeys, CValueList);},
  1404. 	methods:
  1405. 		{
  1406. 		SaveInfo: function(Info)
  1407. 			{
  1408. 			if (Info.Active.ActionType.GetKind() === 0)
  1409. 				{
  1410. 				for (var i = 0; i < Info.gPassive.length; ++i)
  1411. 					{
  1412. 					if (Info.gPassive[i].gDamage.length > 0)
  1413. 						this.push([Info.Active.Char, Info.Active.ActionType, Info.Active.Skill, Info.Active.gItem],
  1414. 							Info.gPassive[i].gDamage);
  1415. 					}
  1416. 				}
  1417. 			},
  1418. 		Show: function()
  1419. 			{
  1420. 			if (this._gInfo.length > 0)
  1421. 				{
  1422. 				this.CalculateValue();
  1423. 				this.sort();
  1424. 				return this.CreateTable(Local.Text_Table_Damage, "stat_damage",
  1425. 					[Local.Text_Table_Char, Local.Text_Table_AttackType, Local.Text_Table_Skill, Local.Text_Table_Item]);
  1426. 				}
  1427. 			return "";
  1428. 			}
  1429. 		}
  1430. 	});
  1431.  
  1432.  
  1433. var CILHeal = DefineClass({
  1434. 	extend: CInfoList,
  1435. 	construct: function(nKeys, CValueList) {this.superclass(nKeys, CValueList);},
  1436. 	methods:
  1437. 		{
  1438. 		SaveInfo: function(Info)
  1439. 			{
  1440. 			if (Info.Active.ActionType.GetKind() === 1)
  1441. 				{
  1442. 				for (var i = 0; i < Info.gPassive.length; ++i)
  1443. 					{
  1444. 					if (Info.gPassive[i].nHealedHP != null || Info.gPassive[i].nHealedMP != null)
  1445. 						this.push([Info.Active.Char, Info.Active.Skill, Info.Active.gItem],
  1446. 							[Info.gPassive[i].nHealedHP, Info.gPassive[i].nHealedMP]);
  1447. 					}
  1448. 				}
  1449. 			},
  1450. 		Show: function()
  1451. 			{
  1452. 			if (this._gInfo.length > 0)
  1453. 				{
  1454. 				this.CalculateValue();
  1455. 				this.sort();
  1456. 				return this.CreateTable(Local.Text_Table_Heal, "stat_heal",
  1457. 					[Local.Text_Table_Char, Local.Text_Table_Skill, Local.Text_Table_Item]);
  1458. 				}
  1459. 			return "";
  1460. 			}
  1461. 		}
  1462. 	});
  1463.  
  1464.  
  1465. var CILHealed = DefineClass({
  1466. 	extend: CInfoList,
  1467. 	construct: function(nKeys, CValueList) {this.superclass(nKeys, CValueList);},
  1468. 	methods:
  1469. 		{
  1470. 		SaveInfo: function(Info)
  1471. 			{
  1472. 			if (Info.Active.ActionType.GetKind() === 1)
  1473. 				{
  1474. 				for (var i = 0; i < Info.gPassive.length; ++i)
  1475. 					{
  1476. 					if (Info.gPassive[i].nHealedHP != null || Info.gPassive[i].nHealedMP != null)
  1477. 						this.push([Info.gPassive[i].Char],
  1478. 							[Info.gPassive[i].nHealedHP, Info.gPassive[i].nHealedMP]);
  1479. 					}
  1480. 				}
  1481. 			},
  1482. 		Show: function()
  1483. 			{
  1484. 			if (this._gInfo.length > 0)
  1485. 				{
  1486. 				this.CalculateValue();
  1487. 				this.sort();
  1488. 				return this.CreateTable(Local.Text_Table_Healed, "stat_healed", [Local.Text_Table_Char]);
  1489. 				}
  1490. 			return "";
  1491. 			}
  1492. 		}
  1493. 	});
  1494.  
  1495.  
  1496. var CILItemDamage = DefineClass({
  1497. 	extend: CInfoList,
  1498. 	construct: function(nKeys, CValueList) {this.superclass(nKeys, CValueList);},
  1499. 	methods:
  1500. 		{
  1501. 		_SetTableBodyCellContents: function()
  1502. 			{
  1503. 			for (var i = 0; i < this._gInfo.length; ++i)
  1504. 				{
  1505. 				var gBodyCellContent = [];
  1506. 				for (var j = 0; j < this._gInfo[i].gKey.length; ++j)
  1507. 					gBodyCellContent.push( this._gInfo[i].gKey[j] );
  1508.  
  1509. 				gBodyCellContent.push( this._gInfo[i].ValueList.AvgValueStr());
  1510.  
  1511. 				this._Table.SetBodyCellContents.apply(this._Table, gBodyCellContent);
  1512. 				}
  1513. 			},
  1514. 		SaveInfo: function(Info)
  1515. 			{
  1516. 			if (Info.Active.ActionType.GetKind() === 0)
  1517. 				{
  1518. 				for (var i = 0; i < Info.gPassive.length; ++i)
  1519. 					{
  1520. 					if (Info.gPassive[i].nItemDamage != null)
  1521. 						this.push([Info.gPassive[i].Char, Info.gPassive[i].DamagedItem],
  1522. 							Info.gPassive[i].nItemDamage);
  1523. 					}
  1524. 				}
  1525. 			},
  1526. 		Show: function()
  1527. 			{
  1528. 			if (this._gInfo.length > 0)
  1529. 				{
  1530. 				this.CalculateValue();
  1531. 				this.sort();
  1532. 				return this.CreateTable(Local.Text_Table_DamagedItems, "stat_item_damage",
  1533. 					[Local.Text_Table_Char, Local.Text_Table_Item]);
  1534. 				}
  1535. 			return "";
  1536. 			},
  1537. 		CreateTable: function(Title, Id, gKeyName)
  1538. 			{
  1539. 			// Key1, Key2, ..., nDamage
  1540. 			this._Table = new CTable(Title, Id, this._nKeys + 1);
  1541.  
  1542. 			var gHeadCellContent = new Array(this._nKeys + 1);
  1543. 			for (var i = 0; i < this._nKeys; ++i)
  1544. 				gHeadCellContent[i] = gKeyName[i];
  1545. 			gHeadCellContent[this._nKeys] = Local.Text_Table_ItemDamagePoints;
  1546. 			this._Table.SetHeadCellContents.apply(this._Table, gHeadCellContent);
  1547.  
  1548. 			var gBodyCellContentType = new Array(this._nKeys + 1);
  1549. 			for (var i = 0; i < this._nKeys; ++i)
  1550. 				gBodyCellContentType[i] = "string";
  1551. 			gBodyCellContentType[this._nKeys] = "number";
  1552. 			this._Table.SetBodyCellContentTypes.apply(this._Table, gBodyCellContentType);
  1553.  
  1554. 			this._SetTableBodyCellContents();
  1555.  
  1556. 			return this._Table.CreateHTML();
  1557. 			},
  1558. 		push: function(gKey, Value)
  1559. 			{
  1560. 			var ValueList = new this._CValueList();
  1561. 			ValueList.push(Value);
  1562. 			return this._gInfo.push(new CInfoList._CInfo(gKey, ValueList));
  1563. 			}
  1564. 		}
  1565. 	});
  1566.  
  1567.  
  1568. // FUNCTIONS //////////////////////////////////////////////////////////////////
  1569.  
  1570. function CountStat(Document, bLastSubPage)
  1571. 	{
  1572. 	// Read the last round only when reading the last sub page
  1573. 	if (!bLastSubPage) RemoveLastRound(Document);
  1574.  
  1575. 	var Navi = new CNavi(0, 0, 0, 0);
  1576.  
  1577. 	var allRows = Document.getElementsByTagName("tr");
  1578. 	for (var i = 0; i < allRows.length; ++i)
  1579. 		{
  1580. 		var Info = new CActionInfo(Navi);
  1581.  
  1582. 		var IniColumn = first_child(allRows[i]);
  1583. 		GetIniInfo(IniColumn, Info);
  1584. 		if (Info.Active.nIniRoll == null)	// not a initiative column
  1585. 			continue;
  1586. 		++Info.Navi.nRow;
  1587.  
  1588. 		var ActiveColumn = node_after(IniColumn);
  1589. 		GetActiveInfo(ActiveColumn, Info);
  1590.  
  1591. 		switch (Info.Active.ActionType.GetKind())
  1592. 			{
  1593. 			case 0:		// Attack
  1594. 				{
  1595. 				var PassiveColumn = node_after(ActiveColumn);
  1596. 				GetAttackedInfo(PassiveColumn, Info);
  1597. 				break;
  1598. 				}
  1599. 			case 1:		// Heal
  1600. 			case 2:		// Buff
  1601. 				{
  1602. 				var PassiveColumn = node_after(ActiveColumn);
  1603. 				GetHealedBuffedInfo(PassiveColumn, Info);
  1604. 				break;
  1605. 				}
  1606. 			case 3:		// Wait
  1607. 			default:	// Unknown
  1608. 				;
  1609. 			}
  1610. 		Stat.SaveInfo(Info);
  1611. 		}
  1612. 	}
  1613.  
  1614.  
  1615. function RemoveLastRound(Document)
  1616. 	{
  1617. 	var allRows = Document.getElementsByTagName("tr");
  1618. 	for (var i = 0; i < allRows.length; ++i)
  1619. 		{
  1620. 		if (allRows[i].className != null &&
  1621. 			allRows[i].className.indexOf("content_table_row_") === 0)
  1622. 			{
  1623. 			var allH1 = allRows[i].getElementsByTagName("h1");
  1624. 			if (allH1[0] != null &&
  1625. 				allH1[0].firstChild != null &&
  1626. 				allH1[0].firstChild.nodeType == 3 &&
  1627. 				allH1[0].firstChild.data == Local.OrigText_LastRound)
  1628. 				{
  1629. 				allRows[i].parentNode.removeChild(allRows[i]);
  1630. 				break;
  1631. 				}
  1632. 			}
  1633. 		}
  1634. 	}
  1635.  
  1636.  
  1637. // return: true: it's not a initiative column, or it's a initiative column and the format is right
  1638. //         false: it's a initiative column but the format is wrong
  1639. function GetIniInfo(Node, Info)
  1640. 	{
  1641. 	if (Node == null || Node.className != "rep_initiative")
  1642. 		return true;
  1643.  
  1644. 	if (Node.innerHTML == "&nbsp;")
  1645. 		return true;
  1646.  
  1647. 	// \1	ini
  1648. 	// \2	current action
  1649. 	// \3	total actions
  1650. 	var Patt_Ini = Local.Pattern_Ini;
  1651. 	var result = Patt_Ini.exec(Node.innerHTML);
  1652. 	if (result == null)
  1653. 		{
  1654. 		DbgMsgAction(Info, "IniInfo: " + Node.innerHTML);
  1655. 		return false;
  1656. 		}
  1657.  
  1658. 	Info.Active.nIniRoll = Number(result[1]);
  1659. 	Info.Active.nCurrAction = Number(result[2]);
  1660. 	Info.Active.nTotalActions = Number(result[3]);
  1661. 	return true;
  1662. 	}
  1663.  
  1664.  
  1665. // return: whether the format is right
  1666. function GetActiveInfo(Node, Info)
  1667. 	{
  1668. 	if (Node == null)
  1669. 		{
  1670. 		DbgMsgAction(Info, "ActiveInfo: null");
  1671. 		return false;
  1672. 		}
  1673. 	var nStartNode = 0;
  1674. 	var Str = Node.innerHTML;
  1675.  
  1676. 	// \1	span node
  1677. 	// \2	npc Id
  1678. 	var Patt_Char = Local.Pattern_Active_Char;
  1679. 	var result = Patt_Char.exec(Str);
  1680. 	if (result == null)
  1681. 		{
  1682. 		DbgMsgAction(Info, "ActiveInfo (Char): " + Node.innerHTML);
  1683. 		return true;
  1684. 		}
  1685. 	var CharNode = result[1] != null ? Node.childNodes[nStartNode].childNodes[0] :
  1686. 		Node.childNodes[nStartNode];
  1687. 	Info.Active.Char = new CChar(CharNode);
  1688. 	Info.Active.nCharId = result[2] != null ? Number(result[2]) : null;
  1689. 	nStartNode += result[1] != null ? 1 : (result[2] != null ? 2 : 1);
  1690. 	Str = Str.substring(result[0].length);
  1691.  
  1692. 	// \1	attack
  1693. 	// \2	heal or buff
  1694. 	// \3	left parenthesis
  1695. 	var Patt_Action1 = Local.Pattern_Active_Action1;
  1696. 	result = Patt_Action1.exec(Str);
  1697. 	if (result == null)
  1698. 		{
  1699. 		// \1	other action
  1700. 		var Patt_Action2 = Local.Pattern_Active_Action2;
  1701. 		result = Patt_Action2.exec(Str);
  1702. 		if (result == null)
  1703. 			{
  1704. 			DbgMsgAction(Info, "ActiveInfo (Action2): " + Node.innerHTML);
  1705. 			return false;
  1706. 			}
  1707. 		Info.Active.ActionType = new CActionType(result[1]);
  1708. 		return true;
  1709. 		}
  1710. 	if (result[1] != null)
  1711. 		{
  1712. 		Info.Active.ActionType = new CActionType(result[1]);
  1713. 		if (Info.Active.ActionType.GetKind() !== 0)
  1714. 			{
  1715. 			DbgMsgAction(Info, "ActiveInfo (Attack Type): " + result[1]);
  1716. 			return false;
  1717. 			}
  1718. 		nStartNode += 1;
  1719. 		Str = Str.substring(result[0].length);
  1720. 		}
  1721. 	else
  1722. 		{
  1723. 		Info.Active.ActionType = new CActionType(result[2]);
  1724. 		if (Info.Active.ActionType.GetKind() !== 1 && Info.Active.ActionType.GetKind() !== 2)
  1725. 			{
  1726. 			DbgMsgAction(Info, "ActiveInfo (Heal/Buff Type): " + result[2]);
  1727. 			return false;
  1728. 			}
  1729. 		Info.Active.Skill = new CSkill(Node.childNodes[nStartNode + 1]);
  1730. 		if (result[3] == null)
  1731. 			return true;
  1732. 		nStartNode += 3;
  1733. 		Str = Str.substring(result[0].length);
  1734. 		}
  1735.  
  1736. 	switch (Info.Active.ActionType.GetKind())
  1737. 		{
  1738. 		case 0:	// attack
  1739. 			{
  1740. 			// \1	single roll
  1741. 			// \2	position n
  1742. 			// \3	multiple roll n
  1743. 			// \4	MP
  1744. 			// \5	item list
  1745. 			var Patt_ActtackDetails = Local.Pattern_Active_AttackDetails;
  1746. 			result = Patt_ActtackDetails.exec(Str);
  1747. 			if (result == null)
  1748. 				{
  1749. 				DbgMsgAction(Info, "ActiveInfo (ActtackDetails): " + Node.innerHTML);
  1750. 				return false;
  1751. 				}
  1752. 			Info.Active.Skill = new CSkill(Node.childNodes[nStartNode]);
  1753. 			Info.Active.nAttackRoll = Number(result[1] != null ? result[1] : result[3]);
  1754. 			Info.Active.nSkillMP = result[4] != null ? Number(result[4]) : null;
  1755. 			if (result[5] != null)
  1756. 				{
  1757. 				Info.Active.gItem = new CKeyList();
  1758. 				nStartNode += result[4] != null ? 4 : 2;
  1759. 				var ItemNode;
  1760. 				while ((ItemNode = Node.childNodes[nStartNode]) != null)
  1761. 					{
  1762. 					Info.Active.gItem.push(new CItem(ItemNode));
  1763. 					nStartNode += 2;
  1764. 					}
  1765. 				}
  1766. 			return true;
  1767. 			}
  1768. 		case 1:	// heal
  1769. 		case 2:	// buff
  1770. 			{
  1771. 			// \1	MP
  1772. 			// \2	normal item list
  1773. 			// \3	magical potion
  1774. 			var Patt_HealBuffDetails = Local.Pattern_Active_HealBuffDetails;
  1775. 			result = Patt_HealBuffDetails.exec(Str);
  1776. 			if (result == null)
  1777. 				{
  1778. 				DbgMsgAction(Info, "ActiveInfo (HealBuffDetails): " + Node.innerHTML);
  1779. 				return false;
  1780. 				}
  1781. 			Info.Active.nSkillMP = result[1] != null ? Number(result[1]) : null;
  1782. 			if (result[2] != null)
  1783. 				{
  1784. 				Info.Active.gItem = new CKeyList();
  1785. 				nStartNode += result[1] != null ? 2 : 0;
  1786. 				var ItemNode;
  1787. 				while ((ItemNode = Node.childNodes[nStartNode]) != null)
  1788. 					{
  1789. 					Info.Active.gItem.push(new CItem(ItemNode));
  1790. 					nStartNode += 2;
  1791. 					}
  1792. 				}
  1793. 			else if (result[3] != null)
  1794. 				{
  1795. 				Info.Active.gItem = new CKeyList();
  1796. 				nStartNode += result[1] != null ? 2 : 0;
  1797. 				Info.Active.gItem.push(new CItem(Node.childNodes[nStartNode]));
  1798. 				// nStartNode: determine by the number of reagents
  1799. 				}
  1800. 			return true;
  1801. 			}
  1802. 		default:// impossible, the value can only be 0, 1, or 2
  1803. 			return false;
  1804. 		}
  1805. 	}
  1806.  
  1807.  
  1808. // return: whether the format is right
  1809. function GetAttackedInfo(Node, Info)
  1810. 	{
  1811. 	if (Node == null)
  1812. 		{
  1813. 		DbgMsgAction(Info, "AttackedInfo: null");
  1814. 		return false;
  1815. 		}
  1816. 	var nStartNode = 0;
  1817. 	var Str = Node.innerHTML;
  1818.  
  1819. 	// \1	char span node
  1820. 	// \2	char Id
  1821. 	// \3	skill
  1822. 	// \4	defence roll
  1823. 	// \5	MP
  1824. 	// \6	item list
  1825. 	// \7	hit type
  1826. 	// \8	struck down
  1827. 	// \9	damage list
  1828. 	// \10	item damage
  1829. 	// \11	next flag
  1830. 	var Patt_Attacked = Local.Pattern_Passive_Attacked;
  1831. 	var bEnd = false;
  1832. 	while (!bEnd)
  1833. 		{
  1834. 		var PassiveInfo = new CPassiveInfo();
  1835. 		var result = Patt_Attacked.exec(Str);
  1836. 		if (result == null)
  1837. 			{
  1838. 			DbgMsgAction(Info, "AttackedInfo: " + Node.innerHTML);
  1839. 			return true;
  1840. 			}
  1841. 		var CharNode = result[1] != null ? Node.childNodes[nStartNode].childNodes[0] :
  1842. 			Node.childNodes[nStartNode];
  1843. 		PassiveInfo.Char = new CChar(CharNode);
  1844. 		PassiveInfo.nCharId = result[2] != null ? Number(result[2]) : null;
  1845. 		nStartNode += result[1] != null ? 1 : (result[2] != null ? 2 : 1);
  1846. 		if (result[3] != null)
  1847. 			{
  1848. 			PassiveInfo.Skill = new CSkill(Node.childNodes[nStartNode +1]);
  1849. 			nStartNode += 2;
  1850. 			}
  1851. 		PassiveInfo.nDefenceRoll = Number(result[4]);
  1852. 		if (result[5] != null)
  1853. 			{
  1854. 			PassiveInfo.nSkillMP = Number(result[5]);
  1855. 			nStartNode += 2;
  1856. 			}
  1857. 		if (result[6] != null)
  1858. 			{
  1859. 			PassiveInfo.gItem = new CKeyList();
  1860. 			nStartNode += 1;
  1861. 			var ItemNode = Node.childNodes[nStartNode];
  1862. 			while (ItemNode != null && ItemNode.nodeName == "A")
  1863. 				{
  1864. 				PassiveInfo.gItem.push(new CItem(ItemNode));
  1865. 				nStartNode += 2;
  1866. 				ItemNode = Node.childNodes[nStartNode];
  1867. 				}
  1868. 			}
  1869. 		else
  1870. 			nStartNode += 1;
  1871. 		PassiveInfo.HitType = new CHitType(result[7]);
  1872. 		PassiveInfo.bStruckDown = (result[8] != null);
  1873. 		nStartNode += result[8] != null ? 2 : 1;
  1874. 		if (result[9] != null)
  1875. 			{
  1876. 			PassiveInfo.gDamage = [];
  1877. 			nStartNode += 1;
  1878. 			var DamageNode = Node.childNodes[nStartNode];
  1879. 			while (DamageNode != null && (DamageNode.nodeType == 3 ||
  1880. 				(DamageNode.nodeName == "SPAN" &&
  1881. 				DamageNode.firstChild != null && DamageNode.firstChild.nodeType == 3)))
  1882. 				{
  1883. 				PassiveInfo.gDamage.push(new CDamage(DamageNode));
  1884. 				nStartNode += 2;
  1885. 				DamageNode = Node.childNodes[nStartNode];
  1886. 				}
  1887. 			nStartNode -= 1;
  1888. 			}
  1889. 		if (result[10] != null)
  1890. 			{
  1891. 			PassiveInfo.DamagedItem = new CItem(Node.childNodes[nStartNode +1]);
  1892. 			PassiveInfo.nItemDamage = Number(result[10]);
  1893. 			nStartNode += 3;
  1894. 			}
  1895. 		if (result[11] != null)
  1896. 			nStartNode += 1;
  1897. 		else
  1898. 			bEnd = true;
  1899.  
  1900. 		Info.gPassive.push(PassiveInfo);
  1901. 		Str = Str.substring(result[0].length);
  1902. 		}
  1903. 	return true;
  1904. 	}
  1905.  
  1906.  
  1907. // return: whether the format is right
  1908. function GetHealedBuffedInfo(Node, Info)
  1909. 	{
  1910. 	if (Node == null)
  1911. 		{
  1912. 		DbgMsgAction(Info, "HealedBuffedInfo: null");
  1913. 		return false;
  1914. 		}
  1915. 	var nStartNode = 0;
  1916. 	var Str = Node.innerHTML;
  1917.  
  1918. 	// \1	span node
  1919. 	// \2	char Id
  1920. 	// \3	self
  1921. 	// \4	HP
  1922. 	// \5	MP
  1923. 	// \6	next flag
  1924. 	var Patt_HealedBuffed = Local.Pattern_Passive_Healed_Buffed;
  1925. 	var bEnd = false;
  1926. 	while (!bEnd)
  1927. 		{
  1928. 		var PassiveInfo = new CPassiveInfo();
  1929. 		var result = Patt_HealedBuffed.exec(Str);
  1930. 		if (result == null)
  1931. 			{
  1932. 			DbgMsgAction(Info, "HealedBuffedInfo: " + Node.innerHTML);
  1933. 			return true;
  1934. 			}
  1935. 		if (result[3] != null)
  1936. 			{
  1937. 			PassiveInfo.Char = Info.Active.Char;
  1938. 			PassiveInfo.nCharId = Info.Active.nCharId;
  1939. 			}
  1940. 		else
  1941. 			{
  1942. 			var CharNode = result[1] != null ? Node.childNodes[nStartNode].childNodes[0] :
  1943. 				Node.childNodes[nStartNode];
  1944. 			PassiveInfo.Char = new CChar(CharNode);
  1945. 			PassiveInfo.nCharId = result[2] != null ? Number(result[2]) : null;
  1946. 			nStartNode += result[1] != null ? 1 : (result[2] != null ? 2 : 1);
  1947. 			}
  1948. 		PassiveInfo.nHealedHP = result[4] != null ? Number(result[4]) : null;
  1949. 		PassiveInfo.nHealedMP = result[5] != null ? Number(result[5]) : null;
  1950. 		nStartNode += 1;
  1951. 		if (result[6] != null)
  1952. 			nStartNode += 1;
  1953. 		else
  1954. 			bEnd = true;
  1955.  
  1956. 		Info.gPassive.push(PassiveInfo);
  1957. 		Str = Str.substring(result[0].length);
  1958. 		}
  1959. 	return true;
  1960. 	}
  1961.  
  1962.  
  1963. function DbgMsgAction(Info, Text)
  1964. 	{
  1965. 	if (DEBUG)
  1966. 		alert("[" + Info.Navi.nLevel + "." + Info.Navi.nRoom + "." +
  1967. 			Info.Navi.nRound + "." + Info.Navi.nRow + "] " + Text);
  1968. 	}
  1969.  
  1970.  
  1971. // GLOBAL VARIABLES ///////////////////////////////////////////////////////////
  1972.  
  1973. var DEBUG = false;
  1974.  
  1975. var Contents = {
  1976. 	OrigText_Button_DungeonDetails	: ["details",
  1977. 					   "详细资料"],
  1978. 	OrigText_Button_DuelDetails	: ["Details",
  1979. 					   "详细"],
  1980. 	OrigText_Button_DungeonStat	: ["statistics",
  1981. 					   "统计表"],
  1982. 	OrigText_Level			: ["Level",
  1983. 					   "层数"],
  1984. 	OrigText_LastRound		: ["Last round:",
  1985. 					   "最后回合:"],
  1986. 	OrigTextList_ActionType		: [["attacks", "ranged attacks", "attacks with magic", "socially attacks", "cunningly attacks", "activates on", "works as a force of nature upon", "infected", "casts an explosion at", "deactivated", "magic projectile", "curse", "scare", "heals with", "uses", "summons with", "is unable to do anything.", "looks around in boredom and waits."],
  1987. 					   ["近战攻击", "远程攻击", "魔法攻击", "心理攻击", "偷袭", "触发", "作为自然灾害", "散布", "制造爆炸", "解除", "魔法投射", "诅咒", "恐吓", "治疗", "使用", "召唤", "不能执行任何动作.", "无聊的打量四周，等待着."]],
  1988. 	OrigTextList_DamageType		: [["crushing damage", "cutting damage", "piercing damage", "fire damage", "ice damage", "lightning damage", "poison damage", "acid damage", "psychological damage", "holy damage", "disarm trap", "mana damage"],
  1989. 					   ["粉碎伤害", "切割伤害", "穿刺伤害", "火焰伤害", "寒冰伤害", "闪电伤害", "毒素伤害", "酸性伤害", "心灵伤害", "神圣伤害", "陷阱伤害", "法力伤害"]],
  1990. 	Pattern_Ini			: [/^Initiative ([\d]+)<br><span .*?>Action ([\d]+) of ([\d]+)<\/span>$/,
  1991. 					   /^先攻([\d]+)<br><span .*?>第([\d]+)步行动 \/ 共([\d]+)步<\/span>$/],
  1992. 	Pattern_Active_Char		: [/^(<span .*?>)?<a .*?>.*?<\/a>(?:<span .*?>([\d]+)<\/span>)?(?:<img .*?><\/span>)?/,
  1993. 					   /^(<span .*?>)?<a .*?>.*?<\/a>(?:<span .*?>([\d]+)<\/span>)?(?:<img .*?><\/span>)?/],
  1994. 	Pattern_Active_Action1		: [/^\s*(?:([A-Za-z][A-Za-z ]+[A-Za-z]) +\(|([A-Za-z][A-Za-z ]+[A-Za-z]) +<a .*?>.*?<\/a>(?:( \()|$| on $))/,
  1995. 					   /^\s*(?:([^\u0000-\u007F]+) +\(|([^\u0000-\u007F]+)<a .*?>.*?<\/a>(?:( \()|$|给$))/],
  1996. 	Pattern_Active_Action2		: [/^\s*([\S].*[\S])\s*$/,
  1997. 					   /^\s*([\S].*[\S])\s*$/],
  1998. 	Pattern_Active_AttackDetails	: [/^<a .*?>.*?<\/a>(?:\/([\d]+)|(?:\/([A-Za-z ]+): ([\d]+))+)(?:\/<span .*?>([\d]+) MP<\/span>)?(\/(?:<a .*?>.*?<\/a>,)*<a .*?>.*?<\/a>)?\)$/,
  1999. 					   /^<a .*?>.*?<\/a>(?:\/([\d]+)|(?:\/([^\u0000-\u007F]+): ([\d]+))+)(?:\/<span .*?>([\d]+) 法力<\/span>)?(\/(?:<a .*?>.*?<\/a>,)*<a .*?>.*?<\/a>)?\)$/],
  2000. 	Pattern_Active_HealBuffDetails	: [/^(?:<span .*?>([\d]+) MP<\/span>)?(?:\/)?(?:((<a .*?>.*?<\/a>,)*<a .*?>.*?<\/a>)|(<a .*?>.*?<\/a>\s+(?:<img .*?>)+))?\)(?: on )?$/,
  2001. 					   /^(?:<span .*?>([\d]+) 法力<\/span>)?(?:\/)?(?:((<a .*?>.*?<\/a>,)*<a .*?>.*?<\/a>)|(<a .*?>.*?<\/a>\s+(?:<img .*?>)+))?\)(?:给)?$/],
  2002. 	Pattern_Passive_Attacked	: [/^(<span .*?>)?<a .*?>.*?<\/a>(?:<span .*?>([\d]+)<\/span>)?(?:<img .*?><\/span>)?\s*\((<a .*?>.*?<\/a>\/)?([\d]+)(?:\/<span .*?>([\d]+) MP<\/span>)?(\/(?:<a .*?>.*?<\/a>,)*<a .*?>.*?<\/a>)?\): <span class="([A-Za-z_]+)">[A-Za-z ]+<\/span>( - [A-Za-z ]+)?(<br>(?:<span .*?>)?(?:-)?[\d]+ (?:\[(?:\+|-)[\d]+\] )?[A-Za-z ]+(?:<img .*?><\/span>)?)*(?:<br><a .*?>.*?<\/a> -([\d]+) HP)?(?:(<br>)|$)/,
  2003. 					   /^(<span .*?>)?<a .*?>.*?<\/a>(?:<span .*?>([\d]+)<\/span>)?(?:<img .*?><\/span>)?\s*\((<a .*?>.*?<\/a>\/)?([\d]+)(?:\/<span .*?>([\d]+) 法力<\/span>)?(\/(?:<a .*?>.*?<\/a>,)*<a .*?>.*?<\/a>)?\): <span class="([A-Za-z_]+)">[^\u0000-\u007F]+<\/span>( - [^\u0000-\u007F]+ *)?(<br>(?:<span .*?>)?(?:-)?[\d]+ (?:\[(?:\+|-)[\d]+\] )?[^\u0000-\u007F]+(?:<img .*?><\/span>)?)*(?:<br><a .*?>.*?<\/a> -([\d]+) HP)?(?:(<br>)|$)/],
  2004. 	Pattern_BasicDamage		: [/causes: <b>([\d]+)<\/b>/,
  2005. 					   /造成: <b>([\d]+)<\/b>/],
  2006. 	Pattern_Damage			: [/^((?:-)?[\d]+) (?:\[((?:\+|-)[\d]+)\] )?([A-Za-z][A-Za-z ]+[A-Za-z])$/,
  2007. 					   /^((?:-)?[\d]+) (?:\[((?:\+|-)[\d]+)\] )?([^\u0000-\u007F]+)$/],
  2008. 	Pattern_Passive_Healed_Buffed	: [/^(?:(<span .*?>)?<a .*?>.*?<\/a>(?:<span .*?>([\d]+)<\/span>)?(?:<img .*?><\/span>)?\s+|(themselves))(?: \+([\d]+) HP)?(?: \+([\d]+) MP)?(?:(<br>)|$)/,
  2009. 					   /^(?:(<span .*?>)?<a .*?>.*?<\/a>(?:<span .*?>([\d]+)<\/span>)?(?:<img .*?><\/span>)?\s+|(自己))(?: \+([\d]+) HP)?(?: \+([\d]+) 法力)?(?:(<br>)|$)/],
  2010. 	Text_Button_ExtraStat		: ["Extra Stat",
  2011. 					   "额外统计"],
  2012. 	Text_Button_EntireStat		: ["Entire Extra Stat",
  2013. 					   "全城额外统计"],
  2014. 	Text_Button_Show		: ["Show",
  2015. 					   "显示"],
  2016. 	Text_Button_Default		: ["Default",
  2017. 					   "默认"],
  2018. 	TextList_AttackType		: [["melee", "ranged", "spell", "social", "ambush", "trap", "nature", "disease", "detonate","disarm trap", "magic projectile", "curse", "scare"],
  2019. 					   ["近战", "远程", "魔法", "心理", "偷袭", "陷阱", "自然", "疾病", "爆破", "解除陷阱", "魔法投射", "诅咒", "恐吓"]],
  2020. 	TextList_HitType		: [["failed", "success", "good success", "critical success"],
  2021. 					   ["闪避", "普通", "重击", "致命一击"]],
  2022. 	Text_Loading			: ["Loading",
  2023. 					   "载入中"],
  2024. 	Text_Options			: ["Options:",
  2025. 					   "选项:"],
  2026. 	Text_DefaultMsg			: ["All the data this script stored in your machine has been cleared.",
  2027. 					   "此脚本储存在你的机器上的所有数据已被清除。"],
  2028. 	Text_Table_Ini			: ["Initiative",
  2029. 					   "先攻权"],
  2030. 	Text_Table_Attack		: ["Attack",
  2031. 					   "攻击骰"],
  2032. 	Text_Table_Defence		: ["Defence",
  2033. 					   "防御骰"],
  2034. 	Text_Table_Damage		: ["Damage",
  2035. 					   "伤害"],
  2036. 	Text_Table_Heal			: ["Healing By The Hero",
  2037. 					   "给予治疗"],
  2038. 	Text_Table_Healed		: ["Healing On The Hero",
  2039. 					   "接受治疗"],
  2040. 	Text_Table_DamagedItems		: ["Damaged Items",
  2041. 					   "物品损坏"],
  2042. 	Text_Table_Char			: ["Character",
  2043. 					   "人物"],
  2044. 	Text_Table_AttackType		: ["Attack type",
  2045. 					   "攻击类型"],
  2046. 	Text_Table_DefenceType		: ["Defence type",
  2047. 					   "防御类型"],
  2048. 	Text_Table_Skill		: ["Skill",
  2049. 					   "技能"],
  2050. 	Text_Table_Item			: ["Item",
  2051. 					   "物品"],
  2052. 	Text_Table_AvgRoll		: ["Average roll",
  2053. 					   "平均值"],
  2054. 	Text_Table_Times		: ["Times",
  2055. 					   "次数"],
  2056. 	Text_Table_RollList		: ["Roll list",
  2057. 					   "数值列表"],
  2058. 	Text_Table_ItemDamagePoints	: ["Damage Points",
  2059. 					   "损坏点数"]
  2060. 	};
  2061.  
  2062. var Style = "div.stat_header {margin:1em auto 0.5em auto;} " +
  2063. 	"span.stat_title {margin: auto 1em auto 0em; font-size:20px; font-weight:bold; color:#FFF;} span.clickable {cursor:pointer;} " +
  2064. 	"table[hide] {display:none;} " +
  2065. 	"table.pair_value {width:100%;} table.pair_value td {width:50%; min-width:3em; text-align:right; color:#F8A400;} table.pair_value td + td {color:#00CC00;} ";
  2066.  
  2067. var Local;
  2068. var Stat;
  2069.  
  2070. try {Main();} catch(e) {alert("Main(): " + e);}
  2071.  
  2072.  
  2073. // FUNCTIONS //////////////////////////////////////////////////////////////////
  2074. if( typeof(GM_addStyle)=='undefined' ){function GM_addStyle(styles){         
  2075.         var S = document.createElement('style'); 
  2076.         S.type = 'text/css'; 
  2077.         var T = ''+styles+''; 
  2078.         T = document.createTextNode(T) 
  2079.         S.appendChild(T); 
  2080.         document.body.appendChild(S); 
  2081.         return; 
  2082. }}
  2083.  
  2084. if (!this.GM_getValue || this.GM_getValue.toString().indexOf("not supported")>-1) {
  2085.      this.GM_getValue=function (key,def) {
  2086.          return localStorage[key] || def;
  2087.      };
  2088.      this.GM_setValue=function (key,value) {
  2089.          return localStorage[key]=value;
  2090.     };
  2091.  }
  2092. 		
  2093. function Main()
  2094. 	{
  2095. 	// Language selection
  2096. 	Local = GetLocalContents(Contents);
  2097. 	if (Local === null) return;
  2098.     //GM_log(Local);
  2099. 	// Add CSS
  2100. 	GM_addStyle(Style);
  2101.  
  2102. 	// Add buttons
  2103. 	var KeyButton = AddButtonBesideDisabledButton(
  2104. 		[Local.OrigText_Button_DungeonDetails, Local.Text_Button_ExtraStat, OnCountStat],
  2105. 		[Local.OrigText_Button_DungeonStat, Local.Text_Button_EntireStat, OnCountEntireStat],
  2106. 		[Local.OrigText_Button_DuelDetails, Local.Text_Button_ExtraStat, OnCountStat]);
  2107. 	if (KeyButton === null) return;
  2108.  
  2109. 	// Stat initialization
  2110. 	Stat = new CStat( node_after(KeyButton.parentNode) );
  2111. 	Stat.RegInfoList(new CILIni(		1, CVLNumber));
  2112. 	Stat.RegInfoList(new CILAttackRoll(	4, CVLNumber));
  2113. 	Stat.RegInfoList(new CILDefenceRoll(	4, CVLNumber));
  2114. 	Stat.RegInfoList(new CILDamage(		4, CVLDamage));
  2115. 	Stat.RegInfoList(new CILHeal(		3, CVLPairNumber));
  2116. 	Stat.RegInfoList(new CILHealed(		1, CVLPairNumber));
  2117. 	Stat.RegInfoList(new CILItemDamage(	2, CVLNumber));
  2118. 	}
  2119.  
  2120.  
  2121. // It will only add the first eligible button
  2122. // return: the node of the first eligible disabled button, or null if didn't find anyone
  2123. function AddButtonBesideDisabledButton(/* [DisabledButtonText, ButtonText, ClickEvent], [...], ... */)
  2124. 	{
  2125. 	var allInputs = document.getElementsByTagName("input");
  2126. 	for (var i = 0; i < allInputs.length; ++i)
  2127. 		{
  2128. 		if (allInputs[i].className == "button_disabled")
  2129. 			{
  2130. 			for (var j = 0; j < arguments.length; ++j)
  2131. 				{
  2132. 				if (allInputs[i].getAttribute("value") == arguments[j][0])
  2133. 					{
  2134. 					AddButton(allInputs[i], arguments[j][1], arguments[j][2]);
  2135. 					return allInputs[i];
  2136. 					}
  2137. 				}
  2138. 			}
  2139. 		}
  2140. 	return null;
  2141. 	}
  2142.  
  2143.  
  2144. // Add a button to the end of the given node's parent node
  2145. function AddButton(SiblingNode, Value, OnClick)
  2146. 	{
  2147. 	var newButton = document.createElement("input");
  2148. 	newButton.setAttribute("type", "button");
  2149. 	newButton.setAttribute("class", "button");
  2150. 	newButton.setAttribute("value", Value);
  2151. 	newButton.addEventListener("click", OnClick, false);
  2152. 	var newBlank = document.createTextNode("            ");
  2153. 	SiblingNode.parentNode.appendChild(newBlank);
  2154. 	SiblingNode.parentNode.appendChild(newButton);
  2155. 	}
  2156.  
  2157.  
  2158. function OnCountStat()
  2159. 	{
  2160. 	try	{
  2161. 		if (this.className == "button_disabled")
  2162. 			return;
  2163. 		else
  2164. 			this.className = "button_disabled";
  2165.  
  2166. 		Stat.nTotalPages = 1;
  2167. 		ReadPage(document, true);
  2168. 		}
  2169. 	catch (e) {alert("OnCountStat(): " + e);}
  2170. 	}
  2171.  
  2172.  
  2173. function OnCountEntireStat()
  2174. 	{
  2175. 	try	{
  2176. 		if (this.className == "button_disabled")
  2177. 			return;
  2178. 		else
  2179. 			this.className = "button_disabled";
  2180.  
  2181. 		CountEntireStat();
  2182. 		}
  2183. 	catch (e) {alert("OnCountEntireStat(): " + e);}
  2184. 	}
  2185.  
  2186.  
  2187. function CountEntireStat()
  2188. 	{
  2189. 	var nCurrRepId = GetHiddenInfo(document, "report_id[0]", "");
  2190. 	var nMaxLevel = Stat.nTotalPages = GetStatPageMaxLevel(document, 1);
  2191.  
  2192. 	for (var CurrLevel = 1; CurrLevel <= nMaxLevel; ++CurrLevel)
  2193. 		GetPage(nCurrRepId, CurrLevel, 1, true);
  2194.  
  2195. 	Stat.ShowProgress();
  2196. 	}
  2197.  
  2198.  
  2199. function GetPage(nRepId, nLevel, nRepPage, bFirstRead)
  2200. 	{
  2201. 	var XmlHttp = new XMLHttpRequest();
  2202.  
  2203. 	XmlHttp.onreadystatechange = function ()
  2204. 		{
  2205. 		try	{
  2206. 			if (XmlHttp.readyState == 4 && XmlHttp.status == 200)
  2207. 				{
  2208. 				var Page = document.createElement("div");
  2209. 				Page.innerHTML = XmlHttp.responseText;
  2210. 				ReadPage(Page, bFirstRead);
  2211. 				}
  2212. 			}
  2213. 		catch (e) {alert("XMLHttpRequest.onreadystatechange(): " + e);}
  2214. 		};
  2215.  
  2216. 	var URL = location.protocol + "//" + location.host + "/wod/spiel/dungeon/report.php" +
  2217. 		"?cur_rep_id=" + nRepId +
  2218. 		"&gruppe_id=&current_level=" + nLevel +
  2219. 		"&REPORT_PAGE=" + nRepPage +
  2220. 		"&IS_POPUP=1";
  2221.  
  2222. 	XmlHttp.open("GET", URL, true);
  2223. 	XmlHttp.send(null);
  2224. 	}
  2225.  
  2226.  
  2227. function ReadPage(Document, bFirstRead)
  2228. 	{
  2229. 	var ret = GetRepPageInfo(Document, [1, 1]);
  2230. 	var nCurrRepPage = ret[0];
  2231. 	var nMaxRepPage = ret[1];
  2232.  
  2233. 	if (bFirstRead && nMaxRepPage > 1)
  2234. 		{
  2235. 		var nRepId = GetHiddenInfo(Document, "report_id[0]", "");
  2236. 		var nLevel = GetHiddenInfo(Document, "current_level", 1);
  2237.  
  2238. 		Stat.nTotalPages += nMaxRepPage -1;
  2239. 		for (var i = 1; i <= nMaxRepPage; ++i)
  2240. 			{
  2241. 			if (i !== nCurrRepPage)
  2242. 				GetPage(nRepId, nLevel, i, false);
  2243. 			}
  2244. 		}
  2245.  
  2246. 	CountStat(Document, (nCurrRepPage === nMaxRepPage));
  2247. 	if (++Stat.nReadPages >= Stat.nTotalPages)
  2248. 		Stat.Show();
  2249. 	else
  2250. 		Stat.ShowProgress();
  2251. 	}
  2252.  
  2253.  
  2254. function GetHiddenInfo(Document, InfoName, DefaultValue)
  2255. 	{
  2256. 	var allInputs = Document.getElementsByTagName("input");
  2257. 	for (var i = 0; i < allInputs.length; ++i)
  2258. 		{
  2259. 		if (allInputs[i].getAttribute("type") == "hidden" &&
  2260. 			allInputs[i].name == InfoName)
  2261. 			return allInputs[i].value;
  2262. 		}
  2263. 	return DefaultValue;
  2264. 	}
  2265.  
  2266.  
  2267. function GetStatPageMaxLevel(Document, DefaultValue)
  2268. 	{
  2269. 	var allTds = Document.getElementsByTagName("td");
  2270. 	for (var i = 0; i < allTds.length; ++i)
  2271. 		{
  2272. 		if (first_child(allTds[i].parentNode) != allTds[i])
  2273. 			continue;
  2274. 		var LevelNode = first_child(allTds[i]);
  2275. 		if (LevelNode != null && LevelNode.nodeType == 3 && LevelNode.data == Local.OrigText_Level)
  2276. 			{
  2277. 			var Patt_Level = /^(?:<span .*?>)?(?:[\d]+)\/([\d]+)(?:<\/span>)?$/;
  2278. 			var result = Patt_Level.exec(node_after(allTds[i]).innerHTML);
  2279. 			if (result == null) return DefaultValue;
  2280. 			return Number(result[1]);
  2281. 			}
  2282. 		}
  2283. 	return DefaultValue;
  2284. 	}
  2285.  
  2286.  
  2287. // return: an array, [0]: nCurrRepPage, [1]: nMaxRepPage
  2288. function GetRepPageInfo(Document, DefaultValue)
  2289. 	{
  2290. 	var ret = [DefaultValue[0], DefaultValue[1]];
  2291.  
  2292. 	var SubPageIndexNode;
  2293. 	var allInputs = Document.getElementsByTagName("input");
  2294. 	for (var i = 0; i < allInputs.length; ++i)
  2295. 		{
  2296. 		if (allInputs[i].value.indexOf("=1=") !== -1)
  2297. 			{
  2298. 			SubPageIndexNode = allInputs[i];
  2299. 			break;
  2300. 			}
  2301. 		}
  2302. 	if (SubPageIndexNode == null)
  2303. 		return ret;
  2304.  
  2305. 	var bIndexEnd = false;
  2306. 	while (!bIndexEnd)
  2307. 		{
  2308. 		var IndexPatt = /=([\d]+)=/;
  2309. 		var target = (SubPageIndexNode.value == null)? SubPageIndexNode.firstChild.textContent:SubPageIndexNode.value;		
  2310. 		var Result = IndexPatt.exec(target);
  2311. 		var nCurrIndex = Number(Result[1]);
  2312.  
  2313. 		if (SubPageIndexNode.className == "paginator_selected clickable")
  2314. 			ret[0] = nCurrIndex;
  2315.  
  2316. 		SubPageIndexNode = node_after(node_after(SubPageIndexNode));
  2317. 		if (SubPageIndexNode == null || SubPageIndexNode.nodeName != "A")
  2318. 			{
  2319. 			ret[1] = nCurrIndex;
  2320. 			bIndexEnd = true;
  2321. 			}
  2322. 		}
  2323.  
  2324. 	return ret;
  2325. 	}