Bearbeiten von „OS2.master“

[[Kategorie:Greasemonkey]]
{| style="background-color:white; font-size:11px; float: right; margin:3px 3px 3px 10px; border:1px solid #999; border-color: #9C1818; border-collapse:collapse;" width=500 cellpadding=3 cellspacing=0
| colspan="2" style="padding:0.3em; background-color:#9C1818; font-size: 18px; color:#FFFFFF" align=center| '''OS2.master'''
|- bgcolor="#FFCC00"
| '''Dateiname'''
| '''os2.master.user.js'''
|- bgcolor="#FFCC00"
| '''Version'''
| '''2.0'''
|- bgcolor="#FFCC00"
| '''Autoren'''
| '''Sebastian Klebba''', [[SC Ludza]]<br> '''Andreas Eckes''', [[Strindheim BK]]<br> '''Sven Loges''', [[Choromonets Odessa]]
|- bgcolor="#FFCC00"
| '''Beschreibung'''
| '''OS 2.0 - Master-Skript Version 2.0'''
|- bgcolor="#FFCC00"
| '''Webseiten'''
| '''sp.php?*'''<br> '''st.php?s=*'''<br> '''showteam.php?s=*'''<br> '''Teamseiten (s = Unterseite)'''<br> '''tplatz.php?t=* (t = Team-Index)'''<br> '''spielpreview.php?*'''<br> '''training.php'''<br> '''ka.php'''
|- bgcolor="#FFCC00"
| '''Funktionalität'''
| '''Hervorhebung von Primärskills (Einzelwerte, Spielerprofil)'''<br> '''Vertikale Trennstriche und Markierung der Maxima (Statistik)'''<br> '''Tausch Kategorien <-> Wettbewerbe (Statistik''')<br> '''Trennstriche zwischen Saisons (Vereinshistorie, Spielerhistorie)'''<br> '''Trennstriche zwischen Abrechnungen (Saisonplan, Kontoauszug)'''<br> '''Eintragen der Runde des Wettbewerbs (Saisonplan)'''<br> '''Popup-Fenster vergr&ouml;&szlig;ern (Tabellenpl&auml;tze, Vorschau)'''
|- bgcolor="#FFCC00"
| '''Letzte Änderung'''
| '''{{REVISIONDAY}}.{{REVISIONMONTH}}.{{REVISIONYEAR}}'''
|- bgcolor="#FFCC00"
|}

== Version 2.0 ==
=== Hinweise ===
Verison 2.0 des Master-Skripts versammelt alle Funktionalit&auml;ten, die bisher auf einzelne Skripts verteilt waren, unter einem Dach. Folgende Skripte sind hier integriert:

* Master (Version 1.0)
* [[OS2.spielplan|Spielplan]]
* [[OS2.training|Training]]

Hinzu kommen ein paar kleinere Erweiterungen (Kontoauszug, Popup-Fenster).<br>
Nach der Installation dieses Skripts sollte in der Skript-Verwaltung gepr&uuml;ft werden, welche Skripts aktuell installiert und aktiv sind und nicht (mehr) ben&ouml;tigte Skripts sollten deaktiviert werden. Bei &Uuml;berschneidungen zwischen unterschiedlichen Skripts kann es zu unerw&uuml;nschten Nebeneffekten kommen.<br>

Welche Funktionen das Skript ausf&uuml;hrt, kann in Grenzen gesteuert werden, indem Variablen im Konfigurations-Abschnitt am Anfang des Codes auf <code>true</code> bzw. <code>false</code> gesetzt werden. Siehe hierzu die Kommentare im Quellcode.

=== Quellcode ===
<pre>
// ==UserScript==
// @name OS2.master
// @version 2.0
// @description OS 2.0 - Master-Skript Version 2.0
// @include http://os.ongapo.com/showteam.php?s=*
// @include http://os.ongapo.com/st.php?s=*
// @include http://os.ongapo.com/tplatz.php?t=*
// @include http://os.ongapo.com/spielpreview.php?*
// @include http://os.ongapo.com/sp.php?*
// @include http://os.ongapo.com/training.php
// @include http://os.ongapo.com/ka.php
// @include http://online-soccer.eu/showteam.php?s=*
// @include http://online-soccer.eu/st.php?s=*
// @include http://online-soccer.eu/tplatz.php?t=*
// @include http://online-soccer.eu/spielpreview.php?*
// @include http://online-soccer.eu/sp.php?*
// @include http://online-soccer.eu/training.php
// @include http://online-soccer.eu/ka.php
// @include http://www.online-soccer.eu/showteam.php?s=*
// @include http://www.online-soccer.eu/st.php?s=*
// @include http://www.online-soccer.eu/tplatz.php?t=*
// @include http://www.online-soccer.eu/spielpreview.php?*
// @include http://www.online-soccer.eu/sp.php?*
// @include http://www.online-soccer.eu/training.php
// @include http://www.online-soccer.eu/ka.php
// ==/UserScript==

// Dieses Skript ist in der Lage, folgendes zu machen:
// Teamansicht - Einzelwerte: Primaerskills hervorheben
// Teamansicht - Saisonplan: Runde eintragen, Abrechnungen trennen
// Teamansicht - Tabellenplaetze: Fenster vergroessern
// Teamansicht - Statistik Saison / Gesamt: Spalten umordnen, Hoechstwerte markieren, Wettbewerbe bzw. Kategorien trennen
// Teamansicht - Vereinshistorie: Saisons trennen
// Vorschau: Fenster vergroessern
// Spielerprofil: Primaerskills hervorheben, Saisons in Historie trennen
// Training: Trainingswahrscheinlichkeiten je nach Einsatzdauer berechnen
// Kontoauszug: Abrechnungen trennen
// Ob diese Aenderungen wirklich durchgefuehrt werden, kann gesteuert werden, indem die folgenden
// Konfigurations-Variablen auf true (wird gemacht) oder false (wird nicht gemacht) gesetzt werden

// Konfiguration ************************************************************************
var einzelwerte = true; // Teamansicht - Einzelwerte bearbeiten?
var spielplan = true; // Saisonplan bearbeiten?
var spielplanRunde = true; // Runde im Saisonplan anzeigen?
var spielplanVorberichteKommentare = true; // Texte "Vorberichte" und "Kommentare" abkuerzen?
var tabellenplaetze = true; // Tabellenplatz-Fenster vergroessern?
var statistiken = true; // Teamansicht - Statistik Saison/Gesamt bearbeiten?
var statistikenUmordnen = true; // In Teamansicht - Statistik Saison/Gesamt Wettbewerbe und Kategorien vertauschen?
var vereinshistorie = true; // Teamansicht - Vereinshistorie bearbeiten?
var spielerprofil = true; // Spielerprofil bearbeiten?
var training = true; // Training bearbeiten?
var vorschau = true; // Vorschau-Fenster vergroessern?
var kontoauszug = true; // Kontoauszug bearbeiten?
// Konfiguration Ende *******************************************************************

var osBlue = "#111166";
var borderString = "solid white 1px";
var url = this.location.href
var pageString = parseURL(url);

// Je nach URL in die Verarbeitungsfunktionen verzweigen
switch (pageString) {
	case "teamansicht": procTeamansicht(); break;
	case "tabellenplatz": if (tabellenplaetze) { procTabellenplaetze(); } break;
	case "vorschau": if (vorschau) { procVorschau(); } break;
	case "spielerprofil": if (spielerprofil) { procSpielerprofil(); } break;
	case "training": if (training) { procTraining(); } break;
	case "kontoauszug": if (kontoauszug) { procKontoauszug(); } break;
}

// **************************************************************************************
// Teamansicht: Diverse Verarbeitungen, teilweise in eigenen Funktionen.
// **************************************************************************************
function procTeamansicht() {
	// Parameter s auslesen
	var regexpS = /s=(\d+)/;
	var s = -1;
	if (regexpS.test(url)) { s = parseInt(regexpS.exec(url)[1]);	}
	switch (true) {
		// Einzelwerte
		case ((s == 2) && einzelwerte):
			var table = document.getElementById("team");
			for (var i = 1; i < table.rows.length - 1; i++) {
				var pos = table.rows[i].cells[0].className;
				var primarySkills = getIdxPriSkillsGlobalPage(pos);
				for (var j  = 0; j < primarySkills.length; j++) {
					table.rows[i].cells[primarySkills[j]].style.color = osBlue;
					table.rows[i].cells[primarySkills[j]].style.backgroundColor = getColor(pos);
				}
			}
			break;
		// Statistiken
		case (((s == 3) || (s == 4)) && statistiken):
			var table = document.getElementsByTagName("table")[1];
			procStatistiken(table);
			break;
		// Saisonplan
		case ((s == 6) && spielplan):
			procSaisonplan();
			break;
		// Vereinshistorie
		case (s == 7):
			var table = document.getElementsByTagName("table")[1];
			var offsets = [2, 1, 0, 0]; // 2 Zeilen oben, 1 Zeile unten ausschliessen
			drawHorizontalLines(table, offsets, 1, 0);
			// Fenster verbreitern
			if (isPopupWindow(this)) { this.resizeBy(this.innerWidth * 0.1, 0); }
			break;
	}
}

// **************************************************************************************
// Statistik-Seiten: Kategorie und Wettbewerb vertauschen, Abrechnungen trennen,
// Hoechstwerte hervorheben.
// **************************************************************************************
function procStatistiken(table) {
	var rowOffsetTop = 2;
	var rowOffsetBottom = 2;
	var colOffset = 4;
	var statistics = new Array();
	var maxValues = new Array();
	var numberOfPlayers = table.rows.length - (rowOffsetTop + rowOffsetBottom);
	var periodicity = (statistikenUmordnen) ? 6 : 4;
	// statistics fuellen
	for (var i = 0; i < numberOfPlayers; i++) {
		statistics[i] = new Array();
		for (var j = colOffset; j < table.rows[i + rowOffsetTop].cells.length; j++) {
			statistics[i][j - colOffset] = parseInt(table.rows[i + rowOffsetTop].cells[j].textContent);
		}
	}
	if (statistikenUmordnen) {
		// Formel zum Index mappen: neu = (alt div 4) + 6 * (alt mod 4)
		var statisticsNew = new Array();
		var idxNeu = 0;
		for (var i = 0; i < statistics.length; i++) {
			statisticsNew[i] = new Array();
			for (var j = 0; j < statistics[i].length; j++) {
				idxNeu = Math.floor(j / 4) + 6 * (j % 4);
				statisticsNew[i][idxNeu] = statistics[i][j];
			}
		}
		// Umgeordnete Werte eintragen
		for (var i = 0; i < statistics.length; i++) {
			for (var j = 0; j < statistics[i].length; j++) {
				table.rows[i + rowOffsetTop].cells[j + colOffset].textContent = statisticsNew[i][j];
			}
		}
		// Titelzeilen aendern
		changeTitleRow1(table.rows[0]);
		changeTitleRow1(table.rows[table.rows.length - 1]);
		changeTitleRow2(table.rows[1]);
		changeTitleRow2(table.rows[table.rows.length - 2]);
	} else {
		var statisticsNew = statistics;
	}
	// Linien zeichen. Offsets rechts = 1, um keinen Rand bei letzter Spalte zu haben
	var offsets = new Array(rowOffsetTop, rowOffsetBottom, colOffset, 1);
	var offsetsTitleRowTop = new Array(1, table.rows.length - 2, 3, 1);
	var offsetsTitleRowBottom = new Array(table.rows.length - 2, 1, 3, 1);
	drawVerticalLines(table, offsets, periodicity);
	drawVerticalLines(table, offsetsTitleRowTop, periodicity);
	drawVerticalLines(table, offsetsTitleRowBottom, periodicity);
	// maxValues ermitteln. Initialisierung mit 1, um keine Nullen zu markieren
	for (var j = 0; j < 24; j++) {
		maxValues[j] = 1;
		for (var i = 0; i < numberOfPlayers; i++) {
			if (statisticsNew[i][j] > maxValues[j]) { maxValues[j] = statisticsNew[i][j]; }
		}
	}
	// Hoechstwerte hervorheben
	for (var i = 0; i < numberOfPlayers; i++) {
		var pos = table.rows[i + rowOffsetTop].cells[0].className;
		for (var j = 0; j < maxValues.length; j++) {
			if (statisticsNew[i][j] >= maxValues[j]) {
				table.rows[i + rowOffsetTop].cells[j + colOffset].style.color = osBlue;
				table.rows[i + rowOffsetTop].cells[j + colOffset].style.backgroundColor = getColor(pos);
				table.rows[i + rowOffsetTop].cells[j + colOffset].style.fontWeight = "bold";
			}
		}
	}
}

// **************************************************************************************
// Saisonplan: Runde des Wettbewerbs eintragen, Abrechnungen trennen.
// Von Sven Loges. Erweitert um Abfragen der Konfigurations-Variablen.
// **************************************************************************************
function procSaisonplan() {
	table = document.getElementsByTagName("table")[1];
	saisons = document.getElementsByTagName("option");
	var saison = 0;
	for (var i = 0; i < saisons.length; i++) {
		if (saisons[i].outerHTML.indexOf("selected") > -1) {
			saison = saisons[i].textContent;
		}
	}
	anzZATperMonth = (saison < 2) ? 7 : 6;
	rowOffsetUpper = 1;
	rowOffsetLower = 0;
	columnIndexArt = 1;
	columnIndexZus = 5;
	columnIndexKom = 6;
	pokalRunden = new Array("1. Runde", "2. Runde", "3. Runde", "Achtelfinale", "Viertelfinale", "Halbfinale", "Finale");
	qualiRunden = new Array("Quali 1", "Quali 2", "Quali 3");
	oscRunden = new Array("Viertelfinale", "Halbfinale", "Finale");
	oseRunden = new Array("Runde 1", "Runde 2", "Runde 3", "Runde 4", "Achtelfinale", "Viertelfinale", "Halbfinale", "Finale");
	hinrueck = new Array(" Hin", " RÃ¼ck", "");
	var ligaSpieltag = 1;
	var pokalRunde = 0;
	var euroRunde = -1;
	var hinrueckspiel = 0;
	var ZATrueck = 0;
	var ZATkorr = 0;
	var ZAT = 0;
	for (var i = rowOffsetUpper; i < table.rows.length - rowOffsetLower; i++) {
		ZAT++;
		if ((ZAT > 12) && (ZAT % 10 == 5)) {	// paÃŸt fÃ¼r alle Saisons: 12, 20, 30, 40, 48, 58, 68 / 3, 15, 27, 39, 51, 63, 69
			pokalRunde++;
		}
		if ((ZAT + ZATkorr) % 6 == 4) {
			if (ZAT < 63) {
				ZATrueck = ZAT + 2;
				euroRunde++;
				hinrueckspiel = 0;
			} else {
				euroRunde = 10;	// Finale
				hinrueckspiel = 2;
			}
		}
		if (ZAT == ZATrueck) {
			hinrueckspiel = 1;	// 5, 7; 11, 13;  (17, 19)  / 23,   25; 29, 31; 35,  37; 41,  43; 47, 49; 53,  55; 59,  61; 69
			if (saison < 3) {	// 4, 6; 10, 14*; (16, 22*) / 24**, 26; 34, 36; 38*, 42; 44*, 50; 52, 54; 56*, 60; 62*, 66; 70
				if ((ZAT < 18) || (ZAT == 26) || (ZAT == 46)) {
					ZATkorr = 0;
				} else if (ZAT == 22) {
					ZATkorr = 4;
				} else {
					ZATkorr = 2;
				}
				if ((ZAT == 22) || (ZAT == 30)) {
					euroRunde--;	// FrÃ¼her: 3. Quali-RÃ¼ckspiel erst knapp vor 1. Hauptrunde
				}
			}
		}
		kommentar = table.rows[i].cells[columnIndexKom].innerHTML;
		if (spielplanVorberichteKommentare) {
			table.rows[i].cells[columnIndexKom].innerHTML = kommentar.replace("Vorbericht(e)", "V").replace("Kommentar(e)", "K").replace("&amp;", "/");
		}
		spielart = table.rows[i].cells[columnIndexArt].textContent.split(" : ", 2);
		table.rows[i].cells[columnIndexZus].className = table.rows[i].cells[columnIndexArt].className;
		if (table.rows[i].cells[columnIndexZus].textContent == "") {
			var zusatz = spielart[0];
			if (zusatz == "Liga") {
				if (ZAT < 70) {
					zusatz = ligaSpieltag++ + ". Spieltag";
				} else {
					zusatz = "Relegation";
				}
			} else if (zusatz == "LP") {
				zusatz = pokalRunden[pokalRunde];
			} else if ((zusatz == "OSCQ") || (zusatz == "OSEQ")) {
				zusatz = qualiRunden[euroRunde] + hinrueck[hinrueckspiel];
			} else if (zusatz == "OSC") {
				if (ZAT > 51) {
					zusatz = oscRunden[euroRunde - 8] + hinrueck[hinrueckspiel];
				} else {
					gruppenPhase = (euroRunde < 5) ? "HR-Grp. " : "ZR-Grp. ";
					zusatz = gruppenPhase + "Spiel " + (((euroRunde - 2) % 3) * 2 + 1 + hinrueckspiel);
				}
			} else if (zusatz == "OSE") {
				zusatz = oseRunden[euroRunde - 3] + hinrueck[hinrueckspiel];
			} else if (zusatz == "Friendly") {
				zusatz = "";	// irgendwie besser lesbar!
			}
			if (spielplanRunde) {table.rows[i].cells[columnIndexZus].textContent = zusatz; }
		}
		if (i < table.rows.length - rowOffsetLower - 1) {
			if (ZAT % anzZATperMonth == 0) {
				for (var j = 0; j < table.rows[i].cells.length; j++) {
					table.rows[i].cells[j].style.borderBottom = borderString;
				}
			}
		}
	}
}

// **************************************************************************************
// Spielerprofil: Primaerskills hervorheben, Saisons in Spielerhistorie trennen.
// **************************************************************************************
function procSpielerprofil() {
	// Primaerskills hervorheben
	var tdTags = document.getElementsByTagName("td");
	var pos = tdTags[13].textContent;
	var color = getColor(pos);
	var skills = getIdxPriSkillsDetailsPage(pos);
	for (var i = 0; i < skills.length; i++) {
		tdTags[skills[i]].style.color = color;
	}
	// Saisons in Spielerhistorie trennen
	var table = document.getElementById("e").getElementsByTagName("table")[0];
	var offsets = [1, 1, 0, 0]; // Je 1 Zeile oben und unten ausschliessen
	drawHorizontalLines(table, offsets, 1, 5);
}

// **************************************************************************************
// Kontoauszug: Abrechnungen trennen.
// **************************************************************************************
function procKontoauszug() {
	var table = document.getElementsByTagName("table")[0];
	var season = 1;
	var optionTags = document.getElementsByTagName("select")[0].getElementsByTagName("option");
	for (var i = 0; i < optionTags.length; i++) {
		if (optionTags[i].selected) { season = parseInt(optionTags[i].textContent); }
	}
	for (var i = 2; i < table.rows.length; i++) {
		// Pruefen ob Zat-Abrechnung
		var postingText = table.rows[i].cells[3].textContent;
		var regexpPostingText = /Abrechnung ZAT (\d+)/;
		if (regexpPostingText.test(postingText)) {
			var zat = regexpPostingText.exec(postingText)[1];
			// Pruefen ob Ende von Abrechnungszeitraum
			var zatPerMonth = (season == 1) ? 7 : 6;
			if (zat % zatPerMonth == 0) {
				for (var j = 0; j < table.rows[i].cells.length; j++) {
					table.rows[i].cells[j].style.borderTop = borderString;
				}
			}
		}
	}
}

// **************************************************************************************
// Training: Trainingswahrscheinlichkeiten je nach Einsatzart und -dauer anzeigen.
// **************************************************************************************
function procTraining() {
	var warningTable = document.getElementsByTagName("table")[1];
	var table = document.getElementsByTagName("table")[2];
	var titleBankeinsatz = "Bankeinsatz";
	var titleTeilweise = "Teilweise";
	var titleDurchgehend = "Durchgehend";
	// Warnungen hinzufuegen
	var warning1 = "Die Wahrscheinlichkeiten in den Spalten \"" + titleBankeinsatz + "\", \"" + titleTeilweise + "\" und \"" + titleDurchgehend + "\" dienen nur zur Information!"
	var warning2 = "Die maximale Wahrscheinlichkeit einer Aufwertung ist immer 99.00 %!";
	var newCell1 = appendCell(warningTable.insertRow(-1), warning1);
	newCell1.setAttribute("colspan", 4, false);
	var newCell2 = appendCell(warningTable.insertRow(-1), warning2);
	newCell2.setAttribute("colspan", 3, false);
	// Ueberschriften hinzufuegen
	var colWidth = 80;
	var titleRow = table.rows[0];
	appendCell(titleRow, titleBankeinsatz).setAttribute("width", colWidth, false);
	appendCell(titleRow, titleTeilweise).setAttribute("width", colWidth, false);
	appendCell(titleRow, titleDurchgehend).setAttribute("width", colWidth, false);
	// Wahrscheinlichkeiten berechnen und hinzufuegen
	var colIdxChance = 7;
	for (var i = 1; i < table.rows.length; i++) {
		var currentRow = table.rows[i];
		var probabilityString = currentRow.cells[colIdxChance].textContent;
		// Schleife verlassen, wenn Berechnung irrelevant ist
		if ((probabilityString == "0.00 %") || (probabilityString == "Trainerskill zu niedrig!")) { continue; }
		var color = getColor(currentRow.cells[colIdxChance].className);
		for (var j = 1; j <= 3; j++) {
			// Wert von j entscheidet, welcher Faktor zur Berechnung benutzt wird (Art des Einsatzes)
			var factor = 1;
			switch (j) {
				case 1: factor = 1.1; break;
				case 2: factor = 1.25; break;
				case 3: factor = 1.35; break;
			}
			var newProbabilityString = decimalNumberToString(factor * stringToNumber(probabilityString), 2, true);
			appendCell(currentRow, newProbabilityString, color);
		}
	}
}

// **************************************************************************************
// Tabellenplaetze: Fenster vergroessern
// **************************************************************************************
function procTabellenplaetze() {
	if (isPopupWindow(this)) { this.resizeBy(this.innerWidth * 0.1, this.innerHeight * 0.1); }
}

// **************************************************************************************
// Vorschau: Fenster vergroessern
// **************************************************************************************
function procVorschau() {
	if (isPopupWindow(this)) { this.resizeBy(0, this.innerHeight * 1.1); }
}

// ****************************************************************************
// Hilfsfunktionen
// ****************************************************************************

// Fuer Teamansicht - Statistiken: Aendert die erste Titelzeile von "Spiele", ... auf "Liga", ...
function changeTitleRow1(row) {
	var offsetLeft = 1;
	row.deleteCell(-1);	row.deleteCell(-1);
	for (var i = offsetLeft; i < row.cells.length; i++) {
		row.cells[i].colSpan = 6;
		switch (i) {
			case offsetLeft: row.cells[i].textContent = "Liga"; break;
			case offsetLeft + 1: row.cells[i].textContent = "Landespokal"; break;
			case offsetLeft + 2: row.cells[i].textContent = "International"; break;
			case offsetLeft + 3: row.cells[i].textContent = "Friendly"; break;
		}
	}
}

// Fuer Teamansicht - Statistiken: Aendert die zweite Titelzeile von "LI", "LP", ... auf "SP", "TO", ...
function changeTitleRow2(row) {
	var offsetLeft = 3;
	var cell;
	for (var i = offsetLeft; i < row.cells.length; i++) {
		cell = row.cells[i];
		row.cells[i].align = "center";
		switch ((i - offsetLeft) % 6) {
			case 0: cell.textContent = "SP"; break;
			case 1: cell.textContent = "TO"; break;
			case 2: cell.textContent = "VL"; break;
			case 3: cell.textContent = "SC"; break;
			case 4: cell.textContent = "GK"; break;
			case 5: cell.textContent = "RK"; break;
		}
	}
}

// Zeichnet vertikale Linien in eine Tabelle (mit borderRight)
// table: zu bearbeitende Tabelle
// offsets[0]/[1]: Anzahl Zeilen oben/unten, die ignoriert werden; [2]/[3]: Anzahl Spalten links/rechts, die ignoriert werden
// periodicity: Jede periodicity-te Spalte mit Linie versehen
function drawVerticalLines(table, offsets, periodicity) {
	for (var i = offsets[0]; i < table.rows.length - offsets[1]; i++) {
		for (var j = offsets[2]; j < table.rows[i].cells.length - offsets[3]; j++) {
			if (((j - offsets[2] + 1) % periodicity) == 0) {
				table.rows[i].cells[j].style.borderRight = borderString;
			}
		}
	}
}

// Zeichnet horizontale Linien in eine Tabelle (jeweils als unteren Rand von Zellen)
// table: zu bearbeitende Tabelle
// offsets[0]/[1]: Anzahl Zeilen oben/unten, die ignoriert werden; [2]/[3]: Anzahl Spalten links/rechts, die ignoriert werden
// mode = 1: Saisons trennen ("i != i + 1")
// mode = 2: Abrechnungsperioden trennen ("% 7 == 0")
// mode = 3: Abrechnungsperioden trennen ("% 6 == 0")
// colIdx: Index der Spalte, die die zu vergleichenden Werte enthaelt
function drawHorizontalLines(table, offsets, mode, colIdx) {
	for (var i = offsets[0]; i < table.rows.length - offsets[1]; i++) {
		switch (mode) {
			case 1: // Saisons trennen
				var value1 = parseInt(table.rows[i].cells[colIdx].textContent);
				var value2 = parseInt(table.rows[i + 1].cells[colIdx].textContent);
				if (value1 != value2) {
					for (var j = offsets[2]; j < table.rows[i].cells.length - offsets[3]; j++) {
						table.rows[i].cells[j].style.borderBottom = borderString;
					}
				}
				break;
			case 2: // Abrechnungsperioden trennen (Saison 1)
				var value = parseInt(table.rows[i].cells[colIdx].textContent);
				if (value % 7 == 0) {
					for (var j = offsets[2]; j < table.rows[i].cells.length - offsets[3]; j++) {
						table.rows[i].cells[j].style.borderBottom = borderString;
					}
				}
				break;
			case 3: // Abrechnungsperioden trennen (Saisons > 1)
				var value = parseInt(table.rows[i].cells[colIdx].textContent);
				if (value % 6 == 0) {
					for (var j = offsets[2]; j < table.rows[i].cells.length - offsets[3]; j++) {
						table.rows[i].cells[j].style.borderBottom = borderString;
					}
				}
				break;
		}
	}
}

// Gibt true zurueck, wenn das uebergebene Fenster keine sichtbare Menueleiste hat.
// Im Allgemeinen ist das Fenster dann ein Popupfenster.
function isPopupWindow(aWindow) {
	return !(aWindow.menubar && aWindow.menubar.visible);
}

// Fuegt eine Zelle am Ende einer Zeile hinzu, fuellt die Zelle und gibt sie (td-Tag) zurueck.
// row: Zeile, die verlaengert wird
// text: Textinhalt der neuen Zelle
// color: Schriftfarbe der neuen Zelle (z.B. "#FFFFFF" fuer weiss)
// Bei Aufruf ohne Farbe wird die Standardfarbe benutzt
function appendCell(row, content, color) {
	var returnValue = row.insertCell(-1);
	returnValue.textContent = content;
	returnValue.style.color = color;
	return returnValue;
}

// Parst den URL und gibt einen String zurueck, der die Seite identifiziert.
// url: Der URL, der geparst werden soll
function parseURL(url) {
	if (url.match(/\/showteam\.php\?s=/)) { return "teamansicht"; }
	if (url.match(/\/st\.php\?s=/)) { return "teamansicht"; }
	if (url.match(/\/tplatz\.php\?/)) { return "tabellenplatz"; }
	if (url.match(/\/spielpreview\.php\?/)) { return "vorschau"; }
	if (url.match(/\/sp\.php\?/)) { return "spielerprofil"; }
	if (url.match(/\/training\.php/)) { return "training"; }
	if (url.match(/\/ju\.php/)) { return "jugend"; }
	if (url.match(/\/ka\.php/)) { return "kontoauszug"; }
	return "";
}


// ****************************************************************************
// Funktionen, die Zahlen und Zahlenstrings verarbeiten
// ****************************************************************************

// Wandelt eine Dezimalzahl in einen String um ("." als Dezimalzeichen).
// Fuer Prozentzahlen wird der Wert verhundertfacht und " %" rechts angehaengt.
// number: Die Zahl, die umgewandelt werden soll
// decimalDigits: Anzahl der Nachkommastellen in der Ausgabe (werden erzwungen)
// percent: Ob die Zahl als Prozentwert dargestellt werden soll
function decimalNumberToString(number, decimalDigits, percent) {
	var returnValue = "";
	if (percent) { number *= 100; }
	number = number.toFixed(decimalDigits);
	returnValue = number.toString();
	if (percent) { returnValue += " %"; }
	return returnValue;
}

// Wandelt eine ganze Zahl in einen String um ("." als Tausenderzeichen).
// number: Die Zahl, die umgewandelt werden soll
function wholeNumberToString(number) {
	var returnValue = "";
	var temp = "";
	for (var i = number.toString().length - 1; i >= 0; i--) {
		temp += number.toString().charAt(i);
		if ((i % 3 == 0) && (i > 0)) { temp += "."; }
	}
	for (var i = temp.length - 1; i >= 0; i--) {
		returnValue += temp.charAt(i);
	}
	return returnValue;
}

// Wandelt einen String in eine Zahl um.
// Prozentzahlen-Strings werden als Zahl interpretiert (d.h. "100%" -> 1).
// Ganze Zahlen mit Tausenderpunkten werden erkannt, wenn sie mit "." gefolgt von 3 Ziffern enden.
// Dezimalzahlen werden erkannt, wenn sie mit "." gefolgt von beliebig vielen Ziffern enden.
// Da zuerst auf ganze Zahlen geprueft wird, koennen Dezimalzahlen nicht 3 Nachkommaziffern haben.
function stringToNumber(string) {
	// parseXXX interpretiert einen Punkt immer als Dezimaltrennzeichen
	var returnValue = "";
	var percent = false;
	// Buchstaben und Whitespaces entfernen
	string = string.replace(/[\sa-zA-Z]/g, "");
	// Auf % pruefen und % entfernen
	if (string.lastIndexOf("%") != -1) {
		percent = true;
		string = string.replace(/%/g, "");
	}
	var regexpWholeSimple = /^\d+$/;
	var regexpWholeWithDots = /^\d+(\.\d{3}){1,}$/;
	var regexpDecimal = /^\d*\.\d{1,}$/;
	if (regexpWholeSimple.test(string)) {
		// Einfache ganze Zahl
		returnValue = parseInt(string);
	} else if (regexpWholeWithDots.test(string)) {
		// Ganze Zahl mit Tausenderpunkten
		returnValue = parseInt(string.replace(/\./g, ""));
	} else if (regexpDecimal.test(string)) {
		// Dezimalzahl mit Punkt als Trennzeichen
		returnValue = parseFloat(string);
	} else {
		// Kein gueltiger String
		percent = false;
		returnValue = "";
	}
	if (percent) { returnValue /= 100; }
	return returnValue;
}


// ****************************************************************************
// Funktionen, die Konstanten definieren
// ****************************************************************************

// Liefert je nach Position die Indizes der Primaerskills im Spielerprofil.
function getIdxPriSkillsDetailsPage(pos) {
    switch (pos) {
        case "TOR": return new Array(35,37,39,41);
        case "ABW": return new Array(35,37,39,61);
        case "DMI": return new Array(49,53,39,33);
        case "MIT": return new Array(49,53,37,33);
        case "OMI": return new Array(49,53,33,41);
        case "STU": return new Array(31,35,41,37);
        default:    return new Array();
    }
}

// Liefert je nach Position die Indizes der Primaerskills in Teamansicht - Einzelwerte.
function getIdxPriSkillsGlobalPage(pos) {
    switch (pos) {
        case "TOR": return new Array(6,7,8,9);
        case "ABW": return new Array(6,7,8,19);
        case "DMI": return new Array(13,15,8,5);
        case "MIT": return new Array(13,15,7,5);
        case "OMI": return new Array(13,15,9,5);
        case "STU": return new Array(4,6,7,9);
        default:    return new Array();
    }
}

// Liefert die zur Position gehoerige Farbe,
function getColor(pos) {
	switch (pos) {
    	case "TOR": return "#FFFF00";
    	case "ABW": return "#00FF00";
    	case "DMI": return "#3366FF";
    	case "MIT": return "#66FFFF";
    	case "OMI": return "#FF66FF";
    	case "STU": return "#FF0000";
		case "LEI": return "#FFFFFF";
    	default:    return "";
	}
}
</pre>

== Version 1.0 ==
<pre>
// ==UserScript==
// @name OS2.master
// @description Master-Script fuer Online Soccer 2.0
// @include http://os.ongapo.com/sp.php?*
// @include http://os.ongapo.com/st.php?s=*
// @include http://os.ongapo.com/showteam.php?s=*
// @include http://online-soccer.eu/sp.php?*
// @include http://online-soccer.eu/st.php?s=*
// @include http://online-soccer.eu/showteam.php?s=*
// @include http://www.online-soccer.eu/sp.php?*
// @include http://www.online-soccer.eu/st.php?s=*
// @include http://www.online-soccer.eu/showteam.php?s=*
// ==/UserScript==

// Script wird angewendet auf
// - Spielerprofil
// - Teamansicht in Popupfenster
// - Teamansicht in Hauptfenster

// URL-Legende:
// .../showteam.php?s=_Eigenes Team (Browser-Hauptfenster)
// .../st.php?s=_&c=_Beliebiges Team (Popup-Fenster)
// .../sp.php?s=_Spielerprofil
// .../tplatz.php?t=_Tabellenplätze
// sSeitenindex / Spielerindex (im Spielerprofil)
// c, tTeamindex
// s=0Teamübersicht
// s=1Vertragsdaten
// s=2Einzelwerte
// s=3Statistik Saison
// s=4Statistik Gesamt
// s=5Teaminfo
// s=6Saisonplan
// s=7Vereinshistorie
// s=8Transferhistorie
// s=9Leihhistorie

// HTML-Element-IDs im Spielerprofil:
// "te"Ueberschriftszeile
// "a"Spielerdaten
// "c"Transferhistorie
// "d"Leihhistorie
// "e"Spielerhistorie

// Variablen zur Identifikation der Seite
var sp = false;// Spielerprofil
var st = false;// Teamansicht Popupfenster
var showteam = false;// Teamansicht Hauptfenster
var s = -1;// Seitenindex

var url = window.location.href;
var osBlau = "#111166";
var borderString = "solid white 1px";
var playerProfileWindowOffsetY = 80;

// Seite ermitteln
if (url.match(/sp\.php/)) { sp = true; }
if (url.match(/st\.php/)) { st = true; }
if (url.match(/showteam\.php/)) { showteam = true; }
// Wenn nicht Spielerprofil, dann Wert von s (Seitenindex) ermitteln
if (!sp) {
// Annahme: Entscheidend ist jeweils das letzte Vorkommnis von "s=" und ggf. von "&"
var indexS = url.lastIndexOf("s=");
if (showteam) {
// Wert von s setzt sich aus allen Zeichen hinter "s=" zusammen
s = parseInt(url.substring(indexS + 2, url.length));
} else {
// Wert von s setzt sich aus allen Zeichen zwischen "s=" und "&" zusammen
var indexAmpersand = url.lastIndexOf("&");
s = parseInt(url.substring(indexS + 2, indexAmpersand));
}
// Verzweige in unterschiedliche Verarbeitungen je nach Wert von s:
switch(s) {
case 2: procSingleValues(); break;
case 3: procStatistics(); break;
case 4: procStatistics(); break;
case 7: procClubHistory(); break;
}
} else {
// Es handelt sich um das Spielerprofil:
procPlayerData();
procPlayerHistory();
}

// Verarbeitet Spielerprofil "Spielerdaten"
function procPlayerData() {
var tdTags = document.getElementsByTagName("td");// Liste aller "td"-Tags
var tdIndexPos = 13;// Index des td-Tags der Position
var pos = tdTags[tdIndexPos].textContent;// Position des Spielers
var skills = getArrayPositionOfSkillsOnDetailsPage(pos);// Liste der Indizes der Primärskills

for (var i = 0; i < skills.length; i++) {
tdTags[skills[i]].style.color = getColor(pos);
tdTags[skills[i]].style.fontWeight = 'bold';
}
}

// Verarbeitet Spielerprofil "Spielerhistorie"
function procPlayerHistory() {
// Spielerdaten sind in der ersten Tabelle im HTML-Element mit ID "e":
separateSeasons(document.getElementById("e").getElementsByTagName("table")[0], 1, 1, 5);
}

// Verarbeitet Ansicht "Einzelwerte"
function procSingleValues() {
var playerTable = document.getElementById("team");
var rowOffsetUpper = 1;
var rowOffsetLower = 1;

for (var i = rowOffsetUpper; i < playerTable.rows.length - rowOffsetLower; i++ ) {
var pos = playerTable.rows[i].cells[0].className;// Position des Spielers ermitteln
var skills = getArrayPositionOfSkillsOnGlobalPage(pos);// Liste der Indizes der Primärskills
var color = getColor(pos);

for (var j = 0; j < skills.length; j++ ) {
playerTable.rows[i].cells[skills[j]].style.color = osBlau;
playerTable.rows[i].cells[skills[j]].style.backgroundColor = color;
playerTable.rows[i].cells[skills[j]].style.fontWeight = 'bold';
}
}
}

// Verarbeitet Ansichten "Statistik Saison" und "Statistik Gesamt"
function procStatistics() {
var playerTable = document.getElementsByTagName("table")[1];
var statisticsArray = [];// Array der Statistikwerte
var maxValues = [];// Liste der Höchstwerte
var rowOffsetUpper = 2;
var rowOffsetLower = 2;
var columnOffset = 4;// 4 fuehrende Spalten sind irrelevant
var numberOfCompetitions = 4;// 4 Wettbewerbe (LI, LP, IP, FS)
var numberOfCategories = 6;// 6 Kategorien (Spiele, Tore, Vorlagen, Score, Gelb, Rot)

var numberOfPlayers = playerTable.rows.length - (rowOffsetUpper + rowOffsetLower);
var numberOfStatistics = numberOfCategories*numberOfCompetitions;

// statisticsArray füllen
for (var i = 0; i < numberOfPlayers; i++) {
statisticsArray[i] = [];
for (var j = columnOffset; j < playerTable.rows[i + rowOffsetUpper].cells.length; j++) {
statisticsArray[i][j - columnOffset] = parseInt(playerTable.rows[i + rowOffsetUpper].cells[j].textContent);
}
}
// maxValues ermitteln (Initialisierung mit 1, um keine Nullen zu markieren)
for (var j = 0; j < numberOfStatistics; j++) {
maxValues[j] = 1;
for (var i = 0; i < numberOfPlayers; i++) {
if (statisticsArray[i][j] > maxValues[j]) { maxValues[j] = statisticsArray[i][j]; }
}
}
// Höchstwerte markieren
for (var i = 0; i < numberOfPlayers; i++) {
var pos = playerTable.rows[i + rowOffsetUpper].cells[0].className;
for (var j = 0; j < maxValues.length; j++) {
if (statisticsArray[i][j] >= maxValues[j]) {
playerTable.rows[i + rowOffsetUpper].cells[j + columnOffset].style.color = osBlau;
playerTable.rows[i + rowOffsetUpper].cells[j + columnOffset].style.backgroundColor = getColor(pos);
playerTable.rows[i + rowOffsetUpper].cells[j + columnOffset].style.fontWeight = "bold";
}
}
}
// Linien zeichnen
for (var i = rowOffsetUpper; i < playerTable.rows.length - rowOffsetLower; i++) {
for (var j = 0; j < numberOfCategories - 1; j++) {
var columnIndex = numberOfCompetitions*(j + 1) + columnOffset;
playerTable.rows[i].cells[columnIndex].style.borderLeft = borderString;
}
}
// Sonderbehandlung der Über- und Unterschriftszeilen (je 1 Spalte weniger)
for (var j = 0; j < numberOfCategories - 1; j++) {
var columnIndexCompetition = numberOfCompetitions*(j + 1) + columnOffset - 1;
playerTable.rows[1].cells[columnIndexCompetition].style.borderLeft = borderString;
playerTable.rows[playerTable.rows.length - 2].cells[columnIndexCompetition].style.borderLeft = borderString;
}
}

// Verarbeitet Ansicht "Vereinshistorie"
function procClubHistory() {
separateSeasons(document.getElementsByTagName("table")[1], 2, 1, 0);
}

// Zeichnet in einer Tabelle Linien zwischen den Zeilen unterschiedlicher Saisons
// tableTabelle, die veraendert werden soll
// rowOffsetUpperZeilenstartindex fuer Schleife
// rowOffsetLowerZeilenendindex fuer Schleife
// columnIndexSeasonSpaltenindex der Spalte, deren Werte in benachbarten Zeilen verglichen werden
function separateSeasons(table, rowOffsetUpper, rowOffsetLower, columnIndexSeason) {
for (var i = rowOffsetUpper; i < table.rows.length - rowOffsetLower; i++) {
if (table.rows[i].cells[columnIndexSeason].textContent != table.rows[i + 1].cells[columnIndexSeason].textContent) {
for (var j = 0; j < table.rows[i].cells.length; j++) {
table.rows[i].cells[j].style.borderBottom = borderString;
}
}
}
}

// Gibt die Indizes der Primärskills in der Detailansicht zurück
function getArrayPositionOfSkillsOnDetailsPage(pos) {
switch (pos) {
    case "TOR": return new Array(35,37,39,41);
    case "ABW": return new Array(35,37,39,61);
    case "DMI": return new Array(49,53,39,33);
    case "MIT": return new Array(49,53,37,33);
    case "OMI": return new Array(49,53,33,41);
    case "STU": return new Array(31,35,41,37);
    default:return new Array();
}
}

// Gibt die Indizes der Primärskills in der Einzelwertansicht zurück
function getArrayPositionOfSkillsOnGlobalPage(pos) {
switch (pos) {
    case "TOR": return new Array(6,7,8,9);
    case "ABW": return new Array(6,7,8,19);
    case "DMI": return new Array(13,15,8,5);
    case "MIT": return new Array(13,15,7,5);
    case "OMI": return new Array(13,15,9,5);
    case "STU": return new Array(4,6,7,9);
    default:return new Array();
}
}

// Gibt die zur Position gehörige Farbe zurück
function getColor(pos) {
switch (pos) {
case "TOR": return "#FFFF00";
case "ABW": return "#00FF00";
case "DMI": return "#3366FF";
case "MIT": return "#66FFFF";
case "OMI": return "#FF66FF";
case "STU": return "#FF0000";
case "LEI": return "#FFFFFF";
default:return "";
}
}
</pre>