Bearbeiten von „OS2.jugend.user.js“
Zur Navigation springen
Zur Suche springen
Die Bearbeitung kann rückgängig gemacht werden. Bitte prüfe den Vergleich unten, um sicherzustellen, dass du dies tun möchtest, und veröffentliche dann unten deine Änderungen, um die Bearbeitung rückgängig zu machen.
| Aktuelle Version | Dein Text | ||
| Zeile 1: | Zeile 1: | ||
// ==UserScript== | // ==UserScript== | ||
// @name | // @name OS2.jugendV4 | ||
// @namespace | // @namespace http://os.ongapo.com/ | ||
// @version | // @version 0.45 | ||
// @copyright | // @copyright 2013+ | ||
// @author | // @author Andreas Eckes (Strindheim BK) | ||
// @author | // @author Sven Loges (SLC) | ||
// @description | // @description Jugendteam-Script fuer Online Soccer 2.0 | ||
// @include | // @include http*://os.ongapo.com/haupt.php | ||
// @include | // @include http*://os.ongapo.com/haupt.php?changetosecond=* | ||
// @include | // @include http*://os.ongapo.com/ju.php | ||
// @include | // @include http*://os.ongapo.com/ju.php?page=* | ||
// @include | // @include http*://www.os.ongapo.com/haupt.php | ||
// @include | // @include http*://www.os.ongapo.com/haupt.php?changetosecond=* | ||
// @include | // @include http*://www.os.ongapo.com/ju.php | ||
// @include | // @include http*://www.os.ongapo.com/ju.php?page=* | ||
// @include | // @include http*://online-soccer.eu/haupt.php | ||
// @include | // @include http*://online-soccer.eu/haupt.php?changetosecond=* | ||
// @include | // @include http*://online-soccer.eu/ju.php | ||
// @include | // @include http*://online-soccer.eu/ju.php?page=* | ||
// @include | // @include http*://www.online-soccer.eu/haupt.php | ||
// @include | // @include http*://www.online-soccer.eu/haupt.php?changetosecond=* | ||
// @include | // @include http*://www.online-soccer.eu/ju.php | ||
// @include | // @include http*://www.online-soccer.eu/ju.php?page=* | ||
// @grant | // @grant GM_getValue | ||
// @grant | // @grant GM_setValue | ||
// @grant | // @grant GM_deleteValue | ||
// @grant | // @grant GM_registerMenuCommand | ||
// ==/UserScript== | // ==/UserScript== | ||
| Zeile 72: | Zeile 71: | ||
} | } | ||
}; | }; | ||
let myOptMem = __OPTMEM.normal; | |||
// Moegliche Optionen (hier die Standardwerte editieren oder ueber das Benutzermenu setzen): | // Moegliche Optionen (hier die Standardwerte editieren oder ueber das Benutzermenu setzen): | ||
const __OPTCONFIG = { | const __OPTCONFIG = { | ||
'zeigeGeb' : { // Spaltenauswahl fuer Geburtstage (true = anzeigen, false = nicht anzeigen) | |||
'Name' : "showBirthday", | |||
'Type' : __OPTTYPES.SW, | |||
'Default' : false, | |||
'Action' : __OPTACTION.NXT, | |||
'Label' : "Geb. ein", | |||
'Hotkey' : 'G', | |||
'AltLabel' : "Geb. aus", | |||
'AltHotkey' : 'G', | |||
'FormLabel' : "Geburtstag" | |||
}, | |||
'zeigeAlter' : { // Spaltenauswahl fuer dezimales Alter (true = anzeigen, false = nicht anzeigen) | |||
'Name' : "showAge", | |||
'Type' : __OPTTYPES.SW, | |||
'Default' : true, | |||
'Action' : __OPTACTION.NXT, | |||
'Label' : "Alter ein", | |||
'Hotkey' : 'A', | |||
'AltLabel' : "Alter aus", | |||
'AltHotkey' : 'A', | |||
'FormLabel' : "Alter" | |||
}, | |||
'zeigeTal' : { // Spaltenauswahl fuer Talente (true = anzeigen, false = nicht anzeigen) | 'zeigeTal' : { // Spaltenauswahl fuer Talente (true = anzeigen, false = nicht anzeigen) | ||
'Name' : "showTclasses", | 'Name' : "showTclasses", | ||
| Zeile 108: | Zeile 131: | ||
'FormLabel' : "Aufwertung" | 'FormLabel' : "Aufwertung" | ||
}, | }, | ||
' | 'zeigePosition' : { // Position anzeigen | ||
'Name' : " | 'Name' : "showPos", | ||
'Type' : __OPTTYPES.SW, | 'Type' : __OPTTYPES.SW, | ||
'Default' : false, | 'Default' : false, | ||
'Action' : __OPTACTION.NXT, | 'Action' : __OPTACTION.NXT, | ||
'Label' : " | 'Label' : "Position ein", | ||
'Hotkey' : ' | 'Hotkey' : 'P', | ||
'AltLabel' : " | 'AltLabel' : "Position aus", | ||
'AltHotkey' : ' | 'AltHotkey' : 'P', | ||
'FormLabel' : " | 'FormLabel' : "Position" | ||
}, | }, | ||
'zeigeSkill' : { // Spaltenauswahl fuer die aktuellen Werte (true = anzeigen, false = nicht anzeigen) | 'zeigeSkill' : { // Spaltenauswahl fuer die aktuellen Werte (true = anzeigen, false = nicht anzeigen) | ||
| Zeile 140: | Zeile 152: | ||
'AltHotkey' : 'S', | 'AltHotkey' : 'S', | ||
'FormLabel' : "Skill" | 'FormLabel' : "Skill" | ||
}, | }, | ||
'anzahlOpti' : { // Gibt die Anzahl der Opti-Spalten an / 1: nur bester Opti, 2: die beiden besten, ..., 6: Alle inklusive TOR | 'anzahlOpti' : { // Gibt die Anzahl der Opti-Spalten an / 1: nur bester Opti, 2: die beiden besten, ..., 6: Alle inklusive TOR | ||
| Zeile 283: | Zeile 284: | ||
'FormLabel' : "ZAT:|$" | 'FormLabel' : "ZAT:|$" | ||
}, | }, | ||
' | 'birthdays' : { // Datenspeicher fuer Geburtstage der Jugendspieler | ||
'Name' : " | 'Name' : "birthdays", | ||
'Type' : __OPTTYPES.SD, | 'Type' : __OPTTYPES.SD, | ||
'Hidden' : false, | |||
'Hidden' : | |||
'Serial' : true, | 'Serial' : true, | ||
'AutoReset' : true, | 'AutoReset' : true, | ||
'Permanent' : true, | 'Permanent' : true, | ||
'Default' : [], | |||
'Default' : [], | |||
'Submit' : undefined, | 'Submit' : undefined, | ||
'Cols' : 36, | 'Cols' : 36, | ||
| Zeile 315: | Zeile 299: | ||
'Label' : "Geburtstage:" | 'Label' : "Geburtstage:" | ||
}, | }, | ||
' | 'tclasses' : { // Datenspeicher fuer Talente der Jugendspieler (-1=wenig, 0=normal, +1=hoch) | ||
'Name' : " | 'Name' : "tclasses", | ||
'Type' : __OPTTYPES.SD, | 'Type' : __OPTTYPES.SD, | ||
'Hidden' : false, | 'Hidden' : false, | ||
| Zeile 345: | Zeile 329: | ||
'Label' : "Aufwertungen:" | 'Label' : "Aufwertungen:" | ||
}, | }, | ||
' | 'team' : { // Datenspeicher fuer Daten des Erst- bzw. Zweitteams | ||
'Name' : " | 'Name' : "team", | ||
'Type' : __OPTTYPES.SD, | 'Type' : __OPTTYPES.SD, | ||
'Hidden' : false, | 'Hidden' : false, | ||
'Serial' : true, | 'Serial' : true, | ||
'Permanent' : true, | 'Permanent' : true, | ||
'Default' : | 'Default' : { 'Team' : undefined, 'Liga' : undefined, 'Land' : undefined, 'LdNr' : 0, 'LgNr' : 0 }, | ||
'Submit' : undefined, | 'Submit' : undefined, | ||
'Cols' : 36, | 'Cols' : 36, | ||
'Rows' : | 'Rows' : 6, | ||
'Replace' : null, | 'Replace' : null, | ||
'Space' : | 'Space' : 1, | ||
'Label' : " | 'Label' : "Verein:" | ||
}, | }, | ||
' | 'reset' : { // Optionen auf die "Werkseinstellungen" zuruecksetzen | ||
'Name' : " | 'Name' : "reset", | ||
'Type' : __OPTTYPES. | 'Type' : __OPTTYPES.SI, | ||
' | 'Action' : __OPTACTION.RST, | ||
' | 'Label' : "Standard-Optionen", | ||
' | 'Hotkey' : 'r', | ||
' | 'FormLabel' : "" | ||
' | }, | ||
' | 'storage' : { // Browserspeicher fuer die Klicks auf Optionen | ||
' | 'Name' : "storage", | ||
' | 'Type' : __OPTTYPES.MC, | ||
' | 'ValType' : "String", | ||
' | 'Choice' : Object.keys(__OPTMEM), | ||
' | 'Action' : __OPTACTION.NXT, | ||
'Label' : "Speicher: $", | |||
'Hotkey' : 'c', | |||
'FormLabel' : "Speicher:|$" | |||
}, | }, | ||
' | 'oldStorage' : { // Vorheriger Browserspeicher fuer die Klicks auf Optionen | ||
'Name' : " | 'Name' : "oldStorage", | ||
'Type' : __OPTTYPES.SD, | 'Type' : __OPTTYPES.SD, | ||
'AutoReset' : true, | 'AutoReset' : true, | ||
'Hidden' : true | |||
}, | |||
'showForm' : { // Optionen auf der Webseite (true = anzeigen, false = nicht anzeigen) | |||
'Name' : "showForm", | |||
'Type' : __OPTTYPES.SW, | |||
'FormType' : __OPTTYPES.SI, | |||
'Permanent' : true, | 'Permanent' : true, | ||
'Default' : | 'Default' : false, | ||
' | 'Action' : __OPTACTION.NXT, | ||
'Label' : "Optionen anzeigen", | |||
'Hotkey' : 'O', | |||
'AltLabel' : "Optionen verbergen", | |||
'AltHotkey' : 'O', | |||
'Label' : " | |||
' | |||
' | |||
' | |||
'FormLabel' : "" | 'FormLabel' : "" | ||
} | |||
} | |||
}; | }; | ||
| Zeile 447: | Zeile 386: | ||
// ==================== Abschnitt fuer diverse Utilities ==================== | // ==================== Abschnitt fuer diverse Utilities ==================== | ||
// Gibt einen Wert zurueck. Ist dieser nicht definiert | // Gibt einen Wert zurueck. Ist dieser nicht definiert, wird ein Alternativwert geliefert | ||
// value: Ein Wert. Ist dieser nicht undefined | // value: Ein Wert. Ist dieser nicht undefined, wird er zurueckgeliefert | ||
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist | // defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist | ||
// retValue: Falls definiert, Rueckgabe-Wert fuer den Fall, dass value nicht undefined | // retValue: Falls definiert, Rueckgabe-Wert fuer den Fall, dass value nicht undefined ist | ||
// return Der Wert. Sind weder value noch defValue definiert, dann undefined | // return Der Wert. Sind weder value noch defValue definiert, dann undefined | ||
function getValue(value, defValue = undefined, retValue = undefined) { | function getValue(value, defValue = undefined, retValue = undefined) { | ||
return | return (value === undefined) ? defValue : (retValue === undefined) ? value : retValue; | ||
} | } | ||
| Zeile 485: | Zeile 424: | ||
} | } | ||
// Speichert einen beliebiegen (strukturierten) Wert unter einem Namen ab | |||
// name: GM_setValue-Name, unter dem die Daten gespeichert werden | |||
// Speichert einen beliebiegen (strukturierten) Wert unter einem Namen ab | |||
// name: GM_setValue-Name, unter dem die Daten gespeichert werden | |||
// value: Beliebiger (strukturierter) Wert | // value: Beliebiger (strukturierter) Wert | ||
// return String-Darstellung des Wertes | // return String-Darstellung des Wertes | ||
| Zeile 562: | Zeile 485: | ||
function setNextStored(arr, name, value, reload = true, serial = false) { | function setNextStored(arr, name, value, reload = true, serial = false) { | ||
return setStored(name, getNextValue(arr, value), reload, serial); | return setStored(name, getNextValue(arr, value), reload, serial); | ||
} | |||
// Kompatibilitaetsfunktion: Testet, ob der uebergebene Speicher genutzt werden kann | |||
// storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv | |||
function canUseStorage(storage = undefined) { | |||
const __STORAGE = getValue(storage, getValue(myOptMem, __OPTMEM.normal)); | |||
const __MEMORY = __STORAGE.Value; | |||
let ret = false; | |||
if (__MEMORY !== undefined) { | |||
const __TESTITEM = 'canUseStorageTest'; | |||
const __TEST = Math.random().toString(); | |||
__MEMORY.setItem(__TESTITEM, __TEST); | |||
ret = (__MEMORY.getItem(__TESTITEM) === __TEST); | |||
__MEMORY.removeItem(__TESTITEM); | |||
} | |||
console.log("canUseStorage(" + __STORAGE.Name + ") = " + ret); | |||
return ret; | |||
} | } | ||
// Fuehrt die in einem Storage gespeicherte Operation aus | // Fuehrt die in einem Storage gespeicherte Operation aus | ||
// optSet: Set mit den Optionen | // optSet: Set mit den Optionen | ||
// | // storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv | ||
function runStored(optSet, | function runStored(optSet, storage = undefined) { | ||
const __STORAGE = | const __STORAGE = getValue(storage, getValue(myOptMem, __OPTMEM.normal)); | ||
const __MEMORY = __STORAGE.Value; | const __MEMORY = __STORAGE.Value; | ||
const __RUNPREFIX = __STORAGE.Prefix; | const __RUNPREFIX = __STORAGE.Prefix; | ||
| Zeile 650: | Zeile 594: | ||
// return Gesetzter Name der Option | // return Gesetzter Name der Option | ||
function setOptName(opt, name) { | function setOptName(opt, name) { | ||
return (getOptConfig(opt).Name = name); | return (getOptConfig(opt).Name = name); | ||
} | } | ||
| Zeile 682: | Zeile 622: | ||
// ==================== Ende Abschnitt fuer diverse Utilities ==================== | // ==================== Ende Abschnitt fuer diverse Utilities ==================== | ||
// ==================== Abschnitt fuer | // ==================== Abschnitt fuer das Benutzermenu ==================== | ||
// | // Zeigt den Eintrag im Menu einer Option | ||
// opt: Derzeitiger Wert der Option | |||
// menuOn: Text zum Setzen im Menu | |||
// funOn: Funktion zum Setzen | |||
// keyOn: Hotkey zum Setzen im Menu | |||
// | // menuOff: Text zum Ausschalten im Menu | ||
// funOff: Funktion zum Ausschalten | |||
// keyOff: Hotkey zum Ausschalten im Menu | |||
function registerMenuOption(opt, menuOn, funOn, keyOn, menuOff, funOff, keyOff) { | |||
const __ON = (opt ? '*' : ""); | |||
// | const __OFF = (opt ? "" : '*'); | ||
console.log("OPTION " + __ON + menuOn + __ON + " / " + __OFF + menuOff + __OFF); | |||
const | |||
/ | |||
if (opt) { | |||
GM_registerMenuCommand(menuOff, funOff, keyOff); | |||
} else { | |||
GM_registerMenuCommand(menuOn, funOn, keyOn); | |||
} | |||
} | |||
// | // Zeigt den Eintrag im Menu einer Option mit Wahl des naechsten Wertes | ||
const | // opt: Derzeitiger Wert der Option | ||
// arr: Array-Liste mit den moeglichen Optionen | |||
// menu: Text zum Setzen im Menu ($ wird durch gesetzten Wert ersetzt) | |||
// fun: Funktion zum Setzen des naechsten Wertes | |||
// key: Hotkey zum Setzen des naechsten Wertes im Menu | |||
function registerNextMenuOption(opt, arr, menu, fun, key) { | |||
const __MENU = menu.replace('$', opt); | |||
let options = "OPTION " + __MENU; | |||
for (let value of arr) { | |||
if (value === opt) { | |||
options += " / *" + value + '*'; | |||
} else { | |||
options += " / " + value; | |||
} | |||
} | |||
console.log(options); | |||
GM_registerMenuCommand(__MENU, fun, key); | |||
} | } | ||
// | // Zeigt den Eintrag im Menu einer Option, falls nicht hidden | ||
// | // opt: Derzeitiger Wert der Option | ||
function | // menu: Text zum Setzen im Menu ($ wird durch gesetzten Wert ersetzt) | ||
const | // fun: Funktion zum Setzen des naechsten Wertes | ||
const | // key: Hotkey zum Setzen des naechsten Wertes im Menu | ||
// hidden: Angabe, ob Menupunkt nicht sichtbar sein soll (default: sichtbar) | |||
// serial: Serialization fuer komplexe Daten | |||
function registerDataOption(opt, menu, fun, key, hidden = false, serial = true) { | |||
const __VALUE = ((serial && (opt !== undefined)) ? JSON.stringify(opt) : opt); | |||
const __MENU = getValue(menu, "").replace('$', __VALUE); | |||
const __OPTIONS = (hidden ? "HIDDEN " : "") + "OPTION " + __MENU + | |||
getValue(__VALUE, "", " = " + __VALUE); | |||
console.log(__OPTIONS); | |||
if (! hidden) { | |||
GM_registerMenuCommand(__MENU, fun, key); | |||
} | } | ||
} | } | ||
// | // Zeigt den Eintrag im Menu einer Option | ||
// opt: Option | // opt: Config und Value der Option | ||
function registerOption(opt) { | |||
function | const __CONFIG = getOptConfig(opt); | ||
const | |||
if (! __CONFIG.HiddenMenu) { | |||
switch (__CONFIG.Type) { | |||
case __OPTTYPES.MC : registerNextMenuOption(getOptValue(opt), __CONFIG.Choice, | |||
__CONFIG.Label, opt.Action, __CONFIG.Hotkey); | |||
break; | |||
case __OPTTYPES.SW : registerMenuOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey, | |||
__CONFIG.AltLabel, opt.Action, __CONFIG.AltHotkey); | |||
break; | |||
case __OPTTYPES.TF : registerMenuOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey, | |||
__CONFIG.AltLabel, opt.AltAction, __CONFIG.AltHotkey); | |||
break; | |||
case __OPTTYPES.SD : registerDataOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey, | |||
__CONFIG.HiddenMenu, __CONFIG.Serial); | |||
break; | |||
case __OPTTYPES.SI : registerDataOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey, | |||
__CONFIG.HiddenMenu, __CONFIG.Serial); | |||
break; | |||
default : break; | |||
} | } | ||
} else { | |||
// Nur Anzeige im Log... | |||
registerDataOption(getOptValue(opt), getOptName(opt), opt.Action, __CONFIG.Hotkey, __CONFIG.HiddenMenu, __CONFIG.Serial); | |||
} | } | ||
} | } | ||
// ==================== Ende Abschnitt fuer | // ==================== Ende Abschnitt fuer das Benutzermenu ==================== | ||
// | // Initialisiert die gesetzten Option | ||
// config: Konfiguration der Option | |||
// return Initialwert der gesetzten Option | |||
function initOptValue(config) { | |||
let value = config.Default; // Standard | |||
switch (config.Type) { | |||
case __OPTTYPES.MC : if ((value === undefined) && (config.Choice !== undefined)) { | |||
value = config.Choice[0]; | |||
} | |||
break; | |||
case __OPTTYPES.SW : break; | |||
case __OPTTYPES.TF : break; | |||
case __OPTTYPES.SD : config.Serial = true; | |||
break; | |||
case __OPTTYPES.SI : break; | |||
default : break; | |||
} | |||
if (config.Serial || config.Hidden) { | |||
config.HiddenMenu = true; | |||
} | |||
return value; | |||
} | } | ||
// | // Initialisiert die Menue-Funktion einer Option | ||
// optSet: | // optAction: Typ der Funktion | ||
function | // item: Key der Option | ||
// optSet: Platz fuer die gesetzten Optionen (und Config) | |||
// return Funktion fuer die Option | |||
function initOptAction(optAction, item = undefined, optSet = undefined) { | |||
var fun; | |||
if (optAction !== undefined) { | |||
const __CONFIG = getOptConfig(getOptByName(optSet, item)); | |||
const __RELOAD = ((__CONFIG !== undefined) ? __CONFIG.ActionReload : false); | |||
switch (optAction) { | |||
} | case __OPTACTION.SET : fun = function() { | ||
return setOptByName(optSet, item, optSet.SetValue, __RELOAD); | |||
}; | |||
break; | |||
case __OPTACTION.NXT : fun = function() { | |||
return setNextOptByName(optSet, item, optSet.SetValue, __RELOAD); | |||
}; | |||
break; | |||
case __OPTACTION.RST : fun = function() { | |||
return resetOptions(optSet, __RELOAD); | |||
}; | |||
break; | |||
default : break; | |||
} | |||
} | |||
return fun; | |||
} | |||
// | // Initialisiert die gesetzten Optionen | ||
// optConfig: Konfiguration der Optionen | |||
// optSet: Platz fuer die gesetzten Optionen | |||
// return Gefuelltes Objekt mit den gesetzten Optionen | |||
function initOptions(optConfig, optSet = undefined) { | |||
var value; | |||
if (optSet === undefined) { | |||
optSet = { }; | |||
} | |||
for (let opt in optConfig) { | |||
const __CONFIG = optConfig[opt]; | |||
const __ALTACTION = getValue(__CONFIG.AltAction, __CONFIG.Action); | |||
optSet[opt] = { | |||
'Config' : __CONFIG, | |||
'Value' : initOptValue(__CONFIG), | |||
'SetValue' : undefined, | |||
'Action' : initOptAction(__CONFIG.Action, opt, optSet), | |||
'AltAction' : initOptAction(__ALTACTION, opt, optSet) | |||
}; | |||
} | |||
return optSet; | |||
} | } | ||
// | // Initialisiert die gesetzten Optionen und den Speicher und laedt die Optionen zum Start | ||
// | // optConfig: Konfiguration der Optionen | ||
// | // optSet: Platz fuer die gesetzten Optionen | ||
// | // return Gefuelltes Objekt mit den gesetzten Optionen | ||
function startOptions(optConfig, optSet = undefined) { | |||
// | const __NORMAL = 'normal'; | ||
const | optSet = initOptions(optConfig, optSet); | ||
// Memory Storage fuer vorherige Speicherung... | |||
const __OLDOPT = optSet.oldStorage; | |||
const __OLDSTORAGE = loadOption(getOpt(__OLDOPT), true); | |||
myOptMem = __OPTMEM[getValue(__OLDSTORAGE, __NORMAL)]; | |||
runStored(optSet); | |||
loadOptions(optSet); | |||
// Memory Storage fuer naechste Speicherung... | |||
const __STORAGE = getOptValue(optSet.storage, __NORMAL); | |||
const __NEWSTORAGE = setOpt(__OLDOPT, __STORAGE, false); | |||
if (! canUseStorage(myOptMem = __OPTMEM[getValue(__NEWSTORAGE, __NORMAL)])) { | |||
const __INAKTIV = 'inaktiv'; | |||
if (__NEWSTORAGE !== __INAKTIV) { | |||
if ( | setOpt(__OLDOPT, __INAKTIV, false); | ||
myOptMem = __OPTMEM[__INAKTIV]; | |||
} | } | ||
} | } | ||
return optSet; | |||
} | } | ||
// | // Installiert die Visualisierung und Steuerung der Optionen | ||
// | // optSet: Platz fuer die gesetzten Optionen | ||
// | // optParams: Eventuell notwendige Parameter zur Initialisierung | ||
// | // 'hideMenu': Optionen werden zwar geladen und genutzt, tauchen aber nicht im Benutzermenu auf | ||
// | // 'menuAnchor': Startpunkt fuer das Optionsmenu auf der Seite | ||
// | // 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar) | ||
// | // 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar) | ||
function | // 'formWidth': Anzahl der Elemente pro Zeile | ||
// 'formBreak': Elementnummer des ersten Zeilenumbruchs | |||
function showOptions(optSet = undefined, optParams = { 'hideMenu' : false }) { | |||
if (! optParams.hideMenu) { | |||
buildMenu(optSet); | |||
} | |||
if ((optParams.menuAnchor !== undefined) && (myOptMem !== __OPTMEM.inaktiv)) { | |||
buildForm(optParams.menuAnchor, optSet, optParams); | |||
} | } | ||
} | } | ||
// | // Setzt eine Option auf einen vorgegebenen Wert | ||
// opt: Config und Value der Option | // Fuer kontrollierte Auswahl des Values siehe setNextOpt() | ||
// opt: Config und vorheriger Value der Option | |||
// value: (Bei allen Typen) Zu setzender Wert | |||
// reload: Seite mit neuem Wert neu laden | |||
// return Gesetzter Wert | |||
function setOpt(opt, value, reload = false) { | |||
return setOptValue(opt, setStored(getOptName(opt), value, reload, getOptConfig(opt).Serial)); | |||
} | } | ||
// | // Ermittelt die naechste moegliche Option | ||
// opt: Config und Value der Option | |||
// | // value: Ggfs. zu setzender Wert | ||
// | // return Zu setzender Wert | ||
// return | function getNextOpt(opt, value = undefined) { | ||
function | const __CONFIG = getOptConfig(opt); | ||
const __VALUE = getOptValue(opt, value); | |||
switch ( | switch (__CONFIG.Type) { | ||
case __OPTTYPES.MC : | case __OPTTYPES.MC : return getValue(value, getNextValue(__CONFIG.Choice, __VALUE)); | ||
case __OPTTYPES.SW : return getValue(value, ! __VALUE); | |||
case __OPTTYPES.TF : return getValue(value, ! __VALUE); | |||
case __OPTTYPES.SD : return getValue(value, __VALUE); | |||
case __OPTTYPES.SW : | |||
case __OPTTYPES.TF : | |||
case __OPTTYPES.SD : | |||
case __OPTTYPES.SI : break; | case __OPTTYPES.SI : break; | ||
default : break; | default : break; | ||
} | } | ||
return __VALUE; | |||
return | |||
} | } | ||
// | // Setzt die naechste moegliche Option | ||
// | // opt: Config und Value der Option | ||
// value: Default fuer ggfs. zu setzenden Wert | |||
// reload: Seite mit neuem Wert neu laden | |||
// return Gesetzter Wert | |||
function setNextOpt(opt, value = undefined, reload = true) { | |||
const __CONFIG = getOptConfig(opt); | |||
return setOpt(opt, getNextOpt(opt, value), reload); | |||
} | |||
// Setzt eine Option auf einen vorgegebenen Wert (Version mit Key) | |||
// Fuer kontrollierte Auswahl des Values siehe setNextOptByName() | |||
// optSet: Platz fuer die gesetzten Optionen (und Config) | |||
// item: Key der Option | // item: Key der Option | ||
// | // value: (Bei allen Typen) Zu setzender Wert | ||
// return | // reload: Seite mit neuem Wert neu laden | ||
function | // return Gesetzter Wert | ||
function setOptByName(optSet, item, value, reload = false) { | |||
const __OPT = getOptByName(optSet, item); | |||
return setOpt(__OPT, value, reload); | |||
} | |||
// Ermittelt die naechste moegliche Option (Version mit Key) | |||
// opt: Config und Value der Option | |||
// optSet: Platz fuer die gesetzten Optionen (und Config) | |||
// item: Key der Option | |||
// value: Ggfs. zu setzender Wert | |||
// return Zu setzender Wert | |||
function getNextOptByName(optSet, item, value = undefined) { | |||
const __OPT = getOptByName(optSet, item); | |||
return | return getNextOpt(__OPT, value); | ||
} | } | ||
// | // Setzt die naechste moegliche Option (Version mit Key) | ||
// | // opt: Config und Value der Option | ||
// optSet: Platz fuer die gesetzten Optionen | // optSet: Platz fuer die gesetzten Optionen (und Config) | ||
// return | // item: Key der Option | ||
function | // value: Ggfs. zu setzender Wert | ||
// reload: Seite mit neuem Wert neu laden | |||
// return Gesetzter Wert | |||
function setNextOptByName(optSet, item, value = undefined, reload = true) { | |||
const __OPT = getOptByName(optSet, item); | |||
return setNextOpt(__OPT, value, reload); | |||
} | |||
// Baut das Benutzermenu auf | |||
// optSet: Gesetzte Optionen | |||
function buildMenu(optSet) { | |||
console.log("buildMenu()"); | |||
for (let opt in optSet) { | |||
registerOption(optSet[opt]); | |||
} | } | ||
} | } | ||
// | // Laedt eine (ueber Menu) gesetzte Option | ||
// | // opt: Zu ladende Option | ||
// | // force: Laedt auch Optionen mit 'AutoReset'-Attribut | ||
// return | // return Gesetzter Wert der gelandenen Option | ||
function | function loadOption(opt, force = false) { | ||
const __CONFIG = getOptConfig(opt); | |||
if (! force && __CONFIG.AutoReset) { | |||
return setOptValue(opt, initOptValue(__CONFIG)); | |||
} else if (__CONFIG.Serial) { | |||
return setOptValue(opt, deserialize(getOptName(opt), getOptValue(opt))); | |||
} else { | |||
return setOptValue(opt, GM_getValue(getOptName(opt), getOptValue(opt))); | |||
} | |||
} | |||
// Laedt die (ueber Menu) gesetzten Optionen | |||
// optSet: Set mit den Optionen | |||
// force: Laedt auch Optionen mit 'AutoReset'-Attribut | |||
// return Set mit den geladenen Optionen | |||
function loadOptions(optSet, force = false) { | |||
for (let opt in optSet) { | |||
loadOption(optSet[opt], force); | |||
} | |||
return optSet; | return optSet; | ||
} | } | ||
// | // Entfernt eine (ueber Menu) gesetzte Option (falls nicht 'Permanent') | ||
// | // opt: Gesetzte Option | ||
// | // force: Entfernt auch Optionen mit 'Permanent'-Attribut | ||
// reset: Setzt bei Erfolg auf Initialwert der Option | |||
// | function deleteOption(opt, force = false, reset = true) { | ||
const __CONFIG = getOptConfig(opt); | |||
if (force || ! __CONFIG.Permanent) { | |||
GM_deleteValue(getOptName(opt)); | |||
if (reset) { | |||
setOptValue(opt, initOptValue(__CONFIG)); | |||
} | |||
} | } | ||
} | |||
// Entfernt die (ueber Menu) gesetzten Optionen (falls nicht 'Permanent') | |||
// optSet: Gesetzte Optionen | |||
// force: Entfernt auch Optionen mit 'Permanent'-Attribut | |||
// reset: Setzt bei Erfolg auf Initialwert der Option | |||
function deleteOptions(optSet, force = false, reset = true) { | |||
for (let opt in optSet) { | |||
deleteOption(optSet[opt], force, reset); | |||
} | } | ||
} | } | ||
// | // Entfernt eine (ueber Menu) gesetzte Option | ||
// opt: Gesetzte Option | |||
// opt: | // name: Neu zu setzender Name (Speicheradresse) | ||
// | // reload: Wert nachladen statt beizubehalten | ||
// | // force: Laedt auch Optionen mit 'AutoReset'-Attribut | ||
// return | // return Umbenannte Option | ||
function | function renameOption(opt, name, reload = false, force = false) { | ||
const __NAME = getOptName(opt); | |||
if (__NAME !== name) { | |||
deleteOption(opt, true, ! reload); | |||
setOptName(opt, name); | |||
if (reload) { | |||
loadOption(opt, force); | |||
} | |||
} | } | ||
return | return opt; | ||
} | } | ||
// Setzt die | // Setzt die Optionen in optSet auf die "Werkseinstellungen" des Skripts | ||
// | // optSet: Gesetzte Optionen | ||
// reload: Seite mit "Werkseinstellungen" neu laden | |||
// reload: Seite mit | function resetOptions(optSet, reload = true) { | ||
// Alle (nicht 'Permanent') gesetzten Optionen entfernen... | |||
function | deleteOptions(optSet, false, ! reload); | ||
if (reload) { | |||
// ... und Seite neu laden (mit "Werkseinstellungen")... | |||
window.location.reload(); | |||
} | |||
} | } | ||
// | // ==================== Spezialisierter Abschnitt fuer Optionen ==================== | ||
// Gesetzte Optionen (wird von initOptions() angelegt und von loadOptions() gefuellt): | |||
} | const __OPTSET = { }; | ||
// | // Teamparameter fuer getrennte Speicherung der Optionen fuer Erst- und Zweitteam... | ||
// | const __MYTEAM = { 'Team' : undefined, 'Liga' : undefined, 'Land' : undefined, 'LdNr' : 0, 'LgNr' : 0 }; | ||
// optSet: Platz fuer die gesetzten Optionen ( | |||
// | // Behandelt die Optionen und laedt das Benutzermenu | ||
// | // optConfig: Konfiguration der Optionen | ||
// return | // optSet: Platz fuer die gesetzten Optionen | ||
function | // optParams: Eventuell notwendige Parameter zur Initialisierung | ||
const | // 'hideMenu': Optionen werden zwar geladen und genutzt, tauchen aber nicht im Benutzermenu auf | ||
// 'teamParams': Getrennte "ligaSize"-Option wird genutzt, hier: __MYTEAM mit 'LdNr'/'LgNr' des Erst- bzw. Zweitteams | |||
// 'menuAnchor': Startpunkt fuer das Optionsmenu auf der Seite | |||
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar) | |||
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar) | |||
// 'formWidth': Anzahl der Elemente pro Zeile | |||
// 'formBreak': Elementnummer des ersten Zeilenumbruchs | |||
// return Gefuelltes Objekt mit den gesetzten Optionen | |||
function buildOptions(optConfig, optSet = undefined, optParams = { 'hideMenu' : false }) { | |||
const __TEAMPARAMS = optParams.teamParams; // Ermittelte Parameter | |||
optSet = startOptions(optConfig, optSet); | |||
if (__TEAMPARAMS !== undefined) { | |||
__MYTEAM.Team = __TEAMPARAMS.Team; | |||
__MYTEAM.Liga = __TEAMPARAMS.Liga; | |||
__MYTEAM.Land = __TEAMPARAMS.Land; | |||
__MYTEAM.LdNr = __TEAMPARAMS.LdNr; | |||
__MYTEAM.LgNr = __TEAMPARAMS.LgNr; | |||
// | console.log("Ermittelt: " + JSON.stringify(__MYTEAM)); | ||
// ... und abspeichern... | |||
setOpt(optSet.team, __MYTEAM, false); | |||
} else { | |||
const __TEAM = getOptValue(optSet.team); // Gespeicherte Parameter | |||
if ((__TEAM !== undefined) && (__TEAM.Land !== undefined)) { | |||
} | __MYTEAM.Team = __TEAM.Team; | ||
__MYTEAM.Liga = __TEAM.Liga; | |||
__MYTEAM.Land = __TEAM.Land; | |||
__MYTEAM.LdNr = __TEAM.LdNr; | |||
__MYTEAM.LgNr = __TEAM.LgNr; | |||
console.log("Gespeichert: " + JSON.stringify(__MYTEAM)); | |||
} else { | |||
console.error("Unbekannt: " + JSON.stringify(__TEAM)); | |||
} | |||
} | |||
if (__MYTEAM.LdNr !== undefined) { | |||
// | // Prefix fuer die Optionen "birthdays", "tclasses" und "progresses"... | ||
const __PREFIX = __MYTEAM.LdNr.toString() + __MYTEAM.LgNr.toString(); | |||
renameOption(optSet.birthdays, __PREFIX + getOptName(optSet.birthdays), true); | |||
renameOption(optSet.tclasses, __PREFIX + getOptName(optSet.tclasses), true); | |||
renameOption(optSet.progresses, __PREFIX + getOptName(optSet.progresses), true); | |||
// ... und nachladen... | |||
loadOption(optSet.birthdays, true); | |||
loadOption(optSet.tclasses, true); | |||
loadOption(optSet.progresses, true); | |||
} | } | ||
showOptions(optSet, optParams); | |||
return optSet; | return optSet; | ||
} | } | ||
// | // ==================== Abschnitt fuer diverse Utilities ==================== | ||
// Legt Input-Felder in einem Form-Konstrukt an, falls noetig | |||
// form: <form>...</form> | |||
// props: Map von name:value-Paaren | |||
// type: Typ der Input-Felder (Default: unsichtbare Daten) | |||
// return Ergaenztes Form-Konstrukt | |||
function addInputField(form, props, type = "hidden") { | |||
for (let fieldName in props) { | |||
if ( | let field = form[fieldName]; | ||
if (! field) { | |||
field = document.createElement("input"); | |||
field.type = type; | |||
field.name = fieldName; | |||
form.appendChild(field); | |||
} | } | ||
field.value = props[fieldName]; | |||
} | } | ||
return form; | |||
} | } | ||
// | // Legt unsichtbare Input-Daten in einem Form-Konstrukt an, falls noetig | ||
// | // form: <form>...</form> | ||
// | // props: Map von name:value-Paaren | ||
// | // return Ergaenztes Form-Konstrukt | ||
// | function addHiddenField(form, props) { | ||
function | return addInputField(form, props, "hidden"); | ||
} | |||
// Helferfunktion fuer alle Browser: Fuegt fuer ein Event eine Reaktion ein | |||
// obj: Betroffenes Objekt, z.B. ein Eingabeelement | |||
// type: Name des Events, z.B. "click" | |||
// callback: Funktion als Reaktion | |||
// capture: Event fuer Parent zuerst (true) oder Child (false als Default) | |||
// return false bei Misserfolg | |||
function addEvent(obj, type, callback, capture = false) { | |||
if (obj.addEventListener) { | |||
return obj.addEventListener(type, callback, capture); | |||
} else if (obj.attachEvent) { | |||
return obj.attachEvent("on" + type, callback); | |||
} else { | |||
console.log("Could not add " + type + " event:"); | |||
console.log(callback); | |||
return false; | |||
} | } | ||
} | } | ||
// | // Helferfunktion fuer alle Browser: Entfernt eine Reaktion fuer ein Event | ||
// | // obj: Betroffenes Objekt, z.B. ein Eingabeelement | ||
// | // type: Name des Events, z.B. "click" | ||
// | // callback: Funktion als Reaktion | ||
// | // capture: Event fuer Parent zuerst (true) oder Child (false als Default) | ||
// return | // return false bei Misserfolg | ||
function | function removeEvent(obj, type, callback, capture = false) { | ||
if (obj.removeEventListener) { | |||
return obj.removeEventListener(type, callback, capture); | |||
} else if (obj.detachEvent) { | |||
return obj.detachEvent("on" + type, callback); | |||
} else { | |||
console.log("Could not remove " + type + " event:"); | |||
console.log(callback); | |||
return false; | |||
} | } | ||
} | } | ||
// | // Helferfunktion fuer alle Browser: Fuegt fuer ein Event eine Reaktion ein | ||
// | // id: ID des betroffenen Eingabeelements | ||
// | // type: Name des Events, z.B. "click" | ||
// | // callback: Funktion als Reaktion | ||
function | // capture: Event fuer Parent zuerst (true) oder Child (false als Default) | ||
// return false bei Misserfolg | |||
function addDocEvent(id, type, callback, capture = false) { | |||
const __OBJ = document.getElementById(id); | |||
return addEvent(__OBJ, type, callback, capture); | |||
} | } | ||
// | // Helferfunktion fuer alle Browser: Entfernt eine Reaktion fuer ein Event | ||
// | // id: ID des betroffenen Eingabeelements | ||
// | // type: Name des Events, z.B. "click" | ||
// | // callback: Funktion als Reaktion | ||
// capture: Event fuer Parent zuerst (true) oder Child (false als Default) | |||
// | // return false bei Misserfolg | ||
function removeDocEvent(id, type, callback, capture = false) { | |||
const __OBJ = document.getElementById(id); | |||
// return | |||
function | |||
return removeEvent(__OBJ, type, callback, capture); | |||
} | |||
// Helferfunktion fuer die Ueberpruefung, ob ein Item sichtbar sein soll | |||
// item: Name des betroffenen Items | |||
// showList: Checkliste der sichtbaren Items (true fuer sichtbar) | |||
// hideList: Checkliste der unsichtbaren Items (true fuer unsichtbar) | |||
// return Angabe, ob das Item sichtbar sein soll | |||
function checkVisible(item, showList, hideList = undefined) { | |||
let show = true; | |||
if (showList !== undefined) { | |||
show = (showList[item] === true); // gesetzt und true | |||
} | |||
if (hideList !== undefined) { | |||
if (hideList[item] === true) { // gesetzt und true | |||
show = false; // NICHT anzeigen | |||
} | } | ||
} | } | ||
return show; | |||
} | } | ||
// | // Helferfunktion fuer die Ermittlung eines Elements der Seite (Default: Tabelle) | ||
// | // index: Laufende Nummer des Elements (0-based) | ||
// | // tag: Tag des Elements ("table") | ||
function | // doc: Dokument (document) | ||
function getTable(index, tag = "table", doc = document) { | |||
const __TAGS = document.getElementsByTagName(tag); | |||
const __TABLE = __TAGS[index]; | |||
return __TABLE; | |||
} | } | ||
// | // Helferfunktion fuer die Ermittlung der Zeilen einer Tabelle | ||
// index: Laufende Nummer des Elements (0-based) | |||
// doc: Dokument (document) | |||
function getRows(index, doc = document) { | |||
const __TABLE = getTable(index, "table", doc); | |||
const __ROWS = (__TABLE === undefined) ? undefined : __TABLE.rows; | |||
return __ROWS; | |||
} | |||
// | // ==================== Abschnitt fuer Optionen auf der Seite ==================== | ||
// | // Liefert den Funktionsaufruf zur Option als String | ||
// opt: Auszufuehrende Option | |||
// isAlt: Angabe, ob AltAction statt Action gemeint ist | |||
// value: Ggfs. zu setzender Wert | |||
// serial: Serialization fuer String-Werte (Select, Textarea) | |||
// storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv | |||
// return String mit dem (reinen) Funktionsaufruf | |||
function getFormAction(opt, isAlt = false, value = undefined, serial = undefined, storage = undefined) { | |||
const __STORAGE = getValue(storage, getValue(myOptMem, __OPTMEM.normal)); | |||
const __MEMORY = __STORAGE.Value; | |||
const __MEMSTR = __STORAGE.Display; | |||
const __RUNPREFIX = __STORAGE.Prefix; | |||
/ | |||
// | |||
// | |||
// | |||
// | |||
// return | |||
function | |||
const | |||
if (__MEMORY !== undefined) { | |||
const __RELOAD = "window.location.reload()"; | |||
const __SETITEM = function(item, val, quotes = true) { | |||
return (__MEMSTR + ".setItem('" + __RUNPREFIX + item + "', " + (quotes ? "'" + val + "'" : val) + "),"); | |||
}; | |||
const __SETITEMS = function(cmd, key = undefined, val = undefined) { | |||
return ('(' + __SETITEM('cmd', cmd) + ((key === undefined) ? "" : | |||
__SETITEM('key', key) + __SETITEM('val', val, false)) + __RELOAD + ')'); | |||
}; | |||
const __CONFIG = getOptConfig(opt); | |||
const __SERIAL = getValue(serial, getValue(__CONFIG.Serial, false)); | |||
const __THISVAL = ((__CONFIG.ValType === "String") ? "'\\x22' + this.value + '\\x22'" : "this.value"); | |||
const | const __TVALUE = getValue(__CONFIG.ValType, __THISVAL, "new " + __CONFIG.ValType + '(' + __THISVAL + ')'); | ||
const __VALSTR = ((value !== undefined) ? JSON.stringify(value) : __SERIAL ? "JSON.stringify(" + __TVALUE + ')' : __TVALUE); | |||
const __ACTION = (isAlt ? getValue(__CONFIG.AltAction, __CONFIG.Action) : __CONFIG.Action); | |||
if ( | if (__ACTION !== undefined) { | ||
switch (__ACTION) { | |||
case __OPTACTION.SET : //return "doActionSet('" + getOptName(opt) + "', " + getNextOpt(opt, __VALSTR) + ')'; | |||
return __SETITEMS('SET', getOptName(opt), __VALSTR); | |||
case __OPTACTION.NXT : //return "doActionNxt('" + getOptName(opt) + "', " + getNextOpt(opt, __VALSTR) + ')'; | |||
return __SETITEMS('NXT', getOptName(opt), __VALSTR); | |||
case __OPTACTION.RST : //return "doActionRst()"; | |||
return __SETITEMS('RST'); | |||
default : break; | |||
} | |||
} | } | ||
} | } | ||
return undefined; | |||
} | |||
// Liefert die Funktionsaufruf zur Option als String | |||
// opt: Auszufuehrende Option | |||
// isAlt: Angabe, ob AltAction statt Action gemeint ist | |||
// value: Ggfs. zu setzender Wert | |||
// type: Event-Typ fuer <input>, z.B. "click" fuer "onclick=" | |||
// serial: Serialization fuer String-Werte (Select, Textarea) | |||
// storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv | |||
// return String mit dem (reinen) Funktionsaufruf | |||
function getFormActionEvent(opt, isAlt = false, value = undefined, type = "click", serial = undefined, storage = undefined) { | |||
const __ACTION = getFormAction(opt, isAlt, value, serial, storage); | |||
return getValue(__ACTION, "", ' on' + type + '="' + __ACTION + '"'); | |||
} | } | ||
// ========== | // Zeigt eine Option auf der Seite als Auswahlbox an | ||
// opt: Anzuzeigende Option | |||
// return String mit dem HTML-Code | |||
function getOptionSelect(opt) { | |||
const __CONFIG = getOptConfig(opt); | |||
const __NAME = getOptName(opt); | |||
const __VALUE = getOptValue(opt); | |||
const __ACTION = getFormActionEvent(opt, false, undefined, "change", undefined); | |||
const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label); | |||
const __LABEL = '<label for="' + __NAME + '">' + __FORMLABEL + '</label>'; | |||
let element = '<select name="' + __NAME + '" id="' + __NAME + '"' + __ACTION + '>'; | |||
for (let value of __CONFIG.Choice) { | |||
element += '\n<option value="' + value + '"' + | |||
((value === __VALUE) ? ' SELECTED' : "") + | |||
'>' + value + '</option>'; | |||
for (let | |||
} | } | ||
element += '\n</select>'; | |||
return | return __LABEL.replace('$', element); | ||
} | } | ||
// | // Zeigt eine Option auf der Seite als Radiobutton an | ||
// opt: Anzuzeigende Option | |||
// | // return String mit dem HTML-Code | ||
// return | function getOptionRadio(opt) { | ||
function | const __CONFIG = getOptConfig(opt); | ||
const __NAME = getOptName(opt); | |||
const __VALUE = getOptValue(opt, false); | |||
const __ACTION = getFormActionEvent(opt, false, true, "click", false); | |||
const __ALTACTION = getFormActionEvent(opt, true, false, "click", false); | |||
const __ELEMENTON = '<input type="radio" name="' + __NAME + | |||
'" id="' + __NAME + 'ON" value="1"' + | |||
(__VALUE ? ' CHECKED' : __ACTION) + | |||
' /><label for="' + __NAME + 'ON">' + | |||
__CONFIG.Label + '</label>'; | |||
const __ELEMENTOFF = '<input type="radio" name="' + __NAME + | |||
'" id="' + __NAME + 'OFF" value="0"' + | |||
(__VALUE ? __ALTACTION : ' CHECKED') + | |||
' /><label for="' + __NAME + 'OFF">' + | |||
__CONFIG.AltLabel + '</label>'; | |||
return [ __ELEMENTON, __ELEMENTOFF ]; | |||
} | } | ||
// | // Zeigt eine Option auf der Seite als Checkbox an | ||
// opt: Anzuzeigende Option | |||
// return String mit dem HTML-Code | |||
function getOptionCheckbox(opt) { | |||
// | const __CONFIG = getOptConfig(opt); | ||
// return | const __NAME = getOptName(opt); | ||
function | const __VALUE = getOptValue(opt, false); | ||
const __ACTION = getFormActionEvent(opt, __VALUE, ! __VALUE, "click", false); | |||
const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label); | |||
return '<input type="checkbox" name="' + __NAME + | |||
'" id="' + __NAME + '" value="' + __VALUE + '"' + | |||
(__VALUE ? ' CHECKED' : "") + __ACTION + ' /><label for="' + | |||
__NAME + '">' + __FORMLABEL + '</label>'; | |||
} | } | ||
// | // Zeigt eine Option auf der Seite als Daten-Textfeld an | ||
// | // opt: Anzuzeigende Option | ||
// | // return String mit dem HTML-Code | ||
function getOptionTextarea(opt) { | |||
const __CONFIG = getOptConfig(opt); | |||
const __NAME = getOptName(opt); | |||
const __VALUE = getOptValue(opt); | |||
const | const __ACTION = getFormActionEvent(opt, false, undefined, "submit", undefined); | ||
const __SUBMIT = getValue(__CONFIG.Submit, ""); | |||
const __ONSUBMIT = ((__SUBMIT.length > 0) ? ' onKeyDown="' + __SUBMIT + '"': ""); | |||
const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label); | |||
const __ELEMENTLABEL = '<label for="' + __NAME + '">' + __FORMLABEL + '</label>'; | |||
const __ELEMENTTEXT = '<textarea name="' + __NAME + '" id="' + __NAME + '" cols="' + __CONFIG.Cols + | |||
'" rows="' + __CONFIG.Rows + '"' + __ONSUBMIT + __ACTION + '>' + | |||
JSON.stringify(__VALUE, __CONFIG.Replace, __CONFIG.Space) + '</textarea>'; | |||
return | return [ __ELEMENTLABEL, __ELEMENTTEXT ]; | ||
} | } | ||
// | // Zeigt eine Option auf der Seite als Button an | ||
// | // opt: Anzuzeigende Option | ||
// | // return String mit dem HTML-Code | ||
function getOptionButton(opt) { | |||
const __CONFIG = getOptConfig(opt); | |||
const __NAME = getOptName(opt); | |||
const __VALUE = getOptValue(opt, false); | |||
const | const __ACTION = getFormActionEvent(opt, __VALUE, ! __VALUE, "click", false); | ||
const __BUTTONLABEL = (__VALUE ? __CONFIG.AltLabel : __CONFIG.Label); | |||
const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label); | |||
return | return '<label for="' + __NAME + '">' + __FORMLABEL + | ||
'</label><input type="button" name="' + __NAME + | |||
'" id="' + __NAME + '" value="' + __BUTTONLABEL + '"' + | |||
__ACTION + '/>'; | |||
} | } | ||
// | // Zeigt eine Option auf der Seite an (je nach Typ) | ||
// | // opt: Anzuzeigende Option | ||
// | // return String mit dem HTML-Code | ||
function getOptionElement(opt) { | |||
const __CONFIG = getOptConfig(opt); | |||
const __TYPE = getValue(__CONFIG.FormType, __CONFIG.Type); | |||
let | let element = ""; | ||
if ( | if (! __CONFIG.Hidden) { | ||
switch (__TYPE) { | |||
case __OPTTYPES.MC : element = getOptionSelect(opt); | |||
break; | |||
if ( | case __OPTTYPES.SW : if (__CONFIG.FormLabel !== undefined) { | ||
element = getOptionCheckbox(opt); | |||
} else { | |||
element = getOptionRadio(opt); | |||
} | |||
break; | |||
case __OPTTYPES.TF : element = getOptionCheckbox(opt); | |||
break; | |||
case __OPTTYPES.SD : element = getOptionTextarea(opt); | |||
break; | |||
case __OPTTYPES.SI : element = getOptionButton(opt); | |||
break; | |||
default : break; | |||
} | |||
if (element.length === 2) { | |||
element = '<div>' + element[0] + '<br />' + element[1] + '</div>'; | |||
} | } | ||
} | } | ||
return | return element; | ||
} | } | ||
// | // Baut das Benutzermenu auf der Seite auf | ||
// | // optSet: Gesetzte Optionen | ||
// | // optParams: Eventuell notwendige Parameter | ||
// | // 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar) | ||
// return | // 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar) | ||
function | // 'formWidth': Anzahl der Elemente pro Zeile | ||
const | // 'formBreak': Elementnummer des ersten Zeilenumbruchs | ||
const | // return String mit dem HTML-Code | ||
function getForm(optSet, optParams = { }) { | |||
const __FORM = '<form id="options" method="POST"><table><tbody><tr>'; | |||
const __FORMEND = '</tr></tbody></table></form>'; | |||
const __FORMWIDTH = getValue(optParams.formWidth, 3); | |||
const __FORMBREAK = getValue(optParams.formBreak, __FORMWIDTH); | |||
// | const __SHOWFORM = getOptValue(optSet.showForm, true) ? optParams.showForm : { 'showForm' : true }; | ||
/ | let form = __FORM; | ||
/ | let count = 0; // Bisher angezeigte Optionen | ||
let column = 0; // Spalte der letzten Option (1-basierend) | |||
const | |||
for (let opt in optSet) { | |||
if (checkVisible(opt, __SHOWFORM, optParams.hideForm)) { | |||
const __ELEMENT = getOptionElement(optSet[opt]); | |||
const __TDOPT = (__ELEMENT.indexOf('|') < 0) ? ' colspan="2"' : ""; | |||
if (__ELEMENT.length > 0) { | |||
if (++count > __FORMBREAK) { | |||
if (++column > __FORMWIDTH) { | |||
column = 1; | |||
} | |||
} | |||
if (column === 1) { | |||
form += '</tr><tr>'; | |||
return | } | ||
form += '\n<td' + __TDOPT + '>' + __ELEMENT.replace('|', '</td><td>') + '</td>'; | |||
} | |||
} | |||
} | |||
form += '\n' + __FORMEND; | |||
return form; | |||
} | } | ||
// | // Fuegt das Script in die Seite ein | ||
// optSet: Gesetzte Optionen | |||
// optParams: Eventuell notwendige Parameter | |||
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar) | |||
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar) | |||
// return String mit dem HTML-Code fuer das Script | |||
function getScript(optSet, optParams = { }) { | |||
//const __SCRIPT = '<script type="text/javascript">function activateMenu() { console.log("TADAAA!"); }</script>'; | |||
//const __SCRIPT = '<script type="text/javascript">\n\tfunction doActionNxt(key, value) { alert("SET " + key + " = " + value); }\n\tfunction doActionNxt(key, value) { alert("SET " + key + " = " + value); }\n\tfunction doActionRst(key, value) { alert("RESET"); }\n</script>'; | |||
//const __FORM = '<form method="POST"><input type="button" id="showOpts" name="showOpts" value="Optionen anzeigen" onclick="activateMenu()" /></form>'; | |||
const __SCRIPT = ""; | |||
// | //window.eval('function activateMenu() { console.log("TADAAA!"); }'); | ||
function | |||
return __SCRIPT; | |||
} | } | ||
// | // Zeigt das Optionsmenu auf der Seite an (im Gegensatz zum Benutzermenu) | ||
// | // anchor: Element, das als Anker fuer die Anzeige dient | ||
// | // optSet: Gesetzte Optionen | ||
// | // optParams: Eventuell notwendige Parameter | ||
// | // 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar) | ||
// | // 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar) | ||
// | // 'formWidth': Anzahl der Elemente pro Zeile | ||
// | // 'formBreak': Elementnummer des ersten Zeilenumbruchs | ||
function | function buildForm(anchor, optSet, optParams = { }) { | ||
const | console.log("buildForm()"); | ||
const __FORM = getForm(optSet, optParams); | |||
const __SCRIPT = getScript(optSet, optParams); | |||
addForm(anchor, __FORM, __SCRIPT); | |||
} | } | ||
// Zeigt | // Informationen zu hinzugefuegten Forms | ||
// | const __FORMS = { }; | ||
// | |||
function | // Zeigt das Optionsmenu auf der Seite an (im Gegensatz zum Benutzermenu) | ||
const | // anchor: Element, das als Anker fuer die Anzeige dient | ||
const | // form: HTML-Form des Optionsmenu (hinten angefuegt) | ||
// script: Script mit Reaktionen | |||
function addForm(anchor, form = "", script = "") { | |||
const __OLDFORM = __FORMS[anchor]; | |||
const __REST = (__OLDFORM === undefined) ? anchor.innerHTML : | |||
anchor.innerHTML.substring(0, anchor.innerHTML.length - __OLDFORM.Script.length - __OLDFORM.Form.length); | |||
__FORMS[anchor] = { 'Script' : script, 'Form' : form }; | |||
anchor.innerHTML = __REST + script + form; | |||
} | } | ||
// | // ==================== Ende Abschnitt fuer Optionen ==================== | ||
// | // ==================== Abschnitt genereller Code zur Anzeige der Jugend ==================== | ||
// Zeitpunktangaben | |||
const __TIME = { | |||
'cre' : 0, // Jugendspieler angelegt (mit 12 Jahren) | |||
'beg' : 1, // Jugendspieler darf trainieren (wird 13 Jahre alt) | |||
'now' : 2, // Aktueller ZAT | |||
'end' : 3 // Jugendspieler wird Ende 18 gezogen (Geb. - 1 bzw. ZAT 71 fuer '?') | |||
}; | |||
// Funktionen *************************************************************************** | |||
// Erschafft die Spieler-Objekte und fuellt sie mit Werten | |||
function init(playerRows, optSet, colIdx, offsetUpper = 1, offsetLower = 0) { | |||
const __SAISON = getOptValue(optSet.saison); | |||
const __CURRZAT = getOptValue(optSet.aktuellerZat); | |||
const __BIRTHDAYS = getOptValue(optSet.birthdays, []); | |||
const __TCLASSES = getOptValue(optSet.tclasses, []); | |||
const __PROGRESSES = getOptValue(optSet.progresses, []); | |||
const __PLAYERS = []; | |||
for (let i = offsetUpper, j = 0; i < playerRows.length - offsetLower; i++, j++) { | |||
const __CELLS = playerRows[i].cells; | |||
const __AGE = getAgeFromHTML(__CELLS, colIdx.Age); | |||
const __SKILLS = getSkillsFromHTML(__CELLS, colIdx); | |||
const __ISGOALIE = isGoalieFromHTML(__CELLS, colIdx.Age); | |||
const __NEWPLAYER = new PlayerRecord(__AGE, __SKILLS, __ISGOALIE); | |||
__NEWPLAYER.initPlayer(__SAISON, __CURRZAT, __BIRTHDAYS[j], __TCLASSES[j], __PROGRESSES[j]); | |||
__PLAYERS[j] = __NEWPLAYER; | |||
} | |||
return | return __PLAYERS; | ||
} | } | ||
// | // Trennt die Gruppen (z.B. Jahrgaenge) mit Linien | ||
function separateGroups(rows, borderString, colIdxSort = 0, offsetUpper = 1, offsetLower = 0, offsetLeft = -1, offsetRight = 0) { | |||
if (offsetLeft < 0) { | |||
function | offsetLeft = colIdxSort; // ab Sortierspalte | ||
} | |||
for (let i = offsetUpper; i < rows.length - offsetLower - 1; i++) { | |||
if (rows[i].cells[colIdxSort].textContent !== rows[i + 1].cells[colIdxSort].textContent) { | |||
for (let j = offsetLeft; j < rows[i].cells.length - offsetRight; j++) { | |||
rows[i].cells[j].style.borderBottom = borderString; | |||
} | |||
} | |||
} | |||
} | |||
// Klasse ColumnManager ***************************************************************** | |||
function ColumnManager(optSet) { | |||
this.geb = getOptValue(optSet.zeigeGeb); | |||
this.tal = getOptValue(optSet.zeigeTal); | |||
this.quo = getOptValue(optSet.zeigeQuote); | |||
this.aufw = getOptValue(optSet.zeigeAufw); | |||
this.alter = getOptValue(optSet.zeigeAlter); | |||
this.skill = getOptValue(optSet.zeigeSkill); | |||
this.pos = getOptValue(optSet.zeigePosition); | |||
this.opti = ((getOptValue(optSet.anzahlOpti) >= 1) && (getOptValue(optSet.anzahlOpti) <= 6)); | |||
this.mw = ((getOptValue(optSet.anzahlMW) >= 1) && (getOptValue(optSet.anzahlMW) <= 6)); | |||
this.anzOpti = getOptValue(optSet.anzahlOpti); | |||
this.anzMw = getOptValue(optSet.anzahlMW); | |||
this.skillE = getOptValue(optSet.zeigeSkillEnde); | |||
this.optiE = ((getOptValue(optSet.anzahlOptiEnde) >= 1) && (getOptValue(optSet.anzahlOptiEnde) <= 6)); | |||
this.mwE = ((getOptValue(optSet.anzahlMWEnde) >= 1) && (getOptValue(optSet.anzahlMWEnde) <= 6)); | |||
this.anzOptiE = getOptValue(optSet.anzahlOptiEnde); | |||
this.anzMwE = getOptValue(optSet.anzahlMWEnde); | |||
this.kennzE = getOptValue(optSet.kennzeichenEnde); | |||
this.toString = function() { | |||
let result = "Skillschnitt\t\t" + this.skill + '\n'; | |||
result += "Beste Position\t" + this.pos + '\n'; | |||
result += "Optis\t\t\t" + this.opti + " (" + this.anzOpti + ")\n"; | |||
} | result += "Marktwerte\t\t" + this.mw + " (" + this.anzMw + ")\n"; | ||
result += "Skillschnitt Ende\t" + this.skillE + '\n'; | |||
result += "Optis Ende\t\t" + this.optiE + " (" + this.anzOptiE + ")\n"; | |||
result += "Marktwerte Ende\t" + this.mwE + " (" + this.anzMwE + ")\n"; | |||
return result; | |||
}; | |||
this.addCell = function(tableRow) { | |||
tableRow.insertCell(-1); | |||
return tableRow.cells.length - 1; | |||
function | }; | ||
this.addAndFillCell = function(tableRow, value, color, digits = 2) { | |||
if (isFinite(value) && (value !== true) && (value !== false)) { | |||
// Zahl einfuegen | |||
if (value < 1000) { | |||
// Mit Nachkommastellen darstellen | |||
tableRow.cells[this.addCell(tableRow)].textContent = parseFloat(value).toFixed(digits); | |||
} else { | |||
// Mit Tausenderpunkten darstellen | |||
tableRow.cells[this.addCell(tableRow)].textContent = getNumberString(value.toString()); | |||
} | |||
} else { | |||
// String einfuegen | |||
tableRow.cells[this.addCell(tableRow)].textContent = value; | |||
} | } | ||
tableRow.cells[tableRow.cells.length - 1].style.color = color; | |||
}; | |||
this.addTitles = function(headers, titleColor = "#FFFFFF") { | |||
// Spaltentitel zentrieren | |||
headers.align = "center"; | |||
if ( | // Titel fuer die aktuellen Werte | ||
if (this.tal) { | |||
this.addAndFillCell(headers, "Talent", titleColor); | |||
} | |||
if (this.quo) { | |||
this.addAndFillCell(headers, "Quote", titleColor); | |||
} | |||
if (this.aufw) { | |||
this.addAndFillCell(headers, "Aufwertung", titleColor); | |||
} | |||
if (this.geb) { | |||
this.addAndFillCell(headers, "Geb.", titleColor); | |||
} | |||
if (this.alter) { | |||
this.addAndFillCell(headers, "Alter", titleColor); | |||
} | |||
if (this.skill) { | |||
this.addAndFillCell(headers, "Skill", titleColor); | |||
} | |||
if (this.pos) { | |||
this.addAndFillCell(headers, "Pos", titleColor); | |||
} | |||
if (this.opti) { | |||
for (let i = 1; i <= this.anzOpti; i++) { | |||
this.addAndFillCell(headers, "Opti " + i, titleColor); | |||
if (this.mw && (this.anzMw >= i)) { | |||
this.addAndFillCell(headers, "MW " + i, titleColor); | |||
} | |||
} | |||
if (this.mw) { | |||
for (let i = this.anzOpti + 1; i <= this.anzMw; i++) { | |||
// Mehr MW- als Opti-Spalten | |||
this.addAndFillCell(headers, "MW " + i, titleColor); | |||
} | |||
} | |||
} else if (this.mw) { | |||
// Keine Opti-, dafuer MW-Spalten | |||
for (let i = 1; i <= this.anzMw; i++) { | |||
this.addAndFillCell(headers, "MW " + i, titleColor); | |||
} | |||
} | } | ||
// | // Titel fuer die Werte mit Ende 18 | ||
if (this.skillE) { | |||
this.addAndFillCell(headers, "Skill" + this.kennzE, titleColor); | |||
} | |||
if (this.optiE) { | |||
for (let i = 1; i <= this.anzOptiE; i++) { | |||
this.addAndFillCell(headers, "Opti " + i + this.kennzE, titleColor); | |||
if (this.mwE && (this.anzMwE >= i)) { | |||
this.addAndFillCell(headers, "MW " + i + this.kennzE, titleColor); | |||
} | } | ||
} | |||
if (this.mwE) { | |||
for (let i = this.anzOptiE + 1; i <= this.anzMwE; i++) { | |||
this.addAndFillCell(headers, "MW " + i + this.kennzE, titleColor); | |||
} | } | ||
} | |||
} else if (this.mwE) { | |||
for (let i = 1; i <= this.anzMwE; i++) { | |||
this.addAndFillCell(headers, "MW " + i + this.kennzE, titleColor); | |||
} | } | ||
} | } | ||
} | }; // Ende addTitles() | ||
this.addValues = function(player, playerRow, color = "#FFFFFF") { | |||
const __COLOR = (player.isGoalie ? getColor("TOR") : color); | |||
const __POS1COLOR = (player.isGoalie ? getColor("TOR") : getColor(player.getPos(1))); | |||
// | // Aktuelle Werte | ||
if (this.tal) { | |||
this.addAndFillCell(playerRow, player.getTalent(), __COLOR); | |||
} | |||
if (this.quo) { | |||
this.addAndFillCell(playerRow, player.getAufwertungsSchnitt(), __COLOR, 2); | |||
} | |||
if (this.aufw) { | |||
this.addAndFillCell(playerRow, player.getAufwert(), __COLOR); | |||
} | |||
if (this.geb) { | |||
this.addAndFillCell(playerRow, player.getGeb(), __COLOR, 0); | |||
} | |||
if (this.alter) { | |||
this.addAndFillCell(playerRow, player.getAge(), __COLOR, 2); | |||
} | |||
if (this.skill) { | |||
this.addAndFillCell(playerRow, player.getSkill(), __COLOR, 2); | |||
} | |||
if (this.pos) { | |||
this.addAndFillCell(playerRow, player.getPos(1), __POS1COLOR); | |||
} | |||
if (this.opti) { | |||
for (let i = 1; i <= this.anzOpti; i++) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-Opti anzeigen | |||
this.addAndFillCell(playerRow, player.getOpti("TOR"), getColor("TOR"), 2); | |||
} else { | |||
// TOR, aber nicht bester Opti -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-Opti anzeigen | |||
this.addAndFillCell(playerRow, player.getOpti(player.getPos(i)), getColor(player.getPos(i)), 2); | |||
} | |||
if (this.mw && (this.anzMw >= i)) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue("TOR"), getColor("TOR"), 0); | |||
} else { | |||
// TOR, aber nicht bester MW -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i)), getColor(player.getPos(i)), 0); | |||
} | |||
} | |||
} | |||
// Verbleibende MW anzeigen | |||
if (this.mw) { | |||
for (let i = this.anzOpti + 1; i <= this.anzMw; i++) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue("TOR"), getColor("TOR"), 0); | |||
} else { | |||
// TOR, aber nicht bester MW -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i)), getColor(player.getPos(i)), 0); | |||
} | |||
} | |||
} | |||
} else if (this.mw) { | |||
// Opti soll nicht angezeigt werden, dafuer aber MW | |||
for (let i = 1; i <= this.anzMw; i++) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue("TOR"), getColor("TOR"), 0); | |||
} else { | |||
// TOR, aber nicht bester MW -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i)), getColor(player.getPos(i)), 0); | |||
} | |||
} | |||
} | |||
// Werte mit Ende 18 | |||
if (this.skillE) { | |||
this.addAndFillCell(playerRow, player.getSkill(__TIME.end), __COLOR, 2); | |||
} | } | ||
if (this.optiE) { | |||
for (let i = 1; i <= this.anzOptiE; i++) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-Opti anzeigen | |||
this.addAndFillCell(playerRow, player.getOpti("TOR", __TIME.end), getColor("TOR"), 2); | |||
} else { | |||
// TOR, aber nicht bester Opti -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-Opti anzeigen | |||
this.addAndFillCell(playerRow, player.getOpti(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 2); | |||
} | |||
if (this.mwE && (this.anzMwE >= i)) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue("TOR", __TIME.end), getColor("TOR"), 0); | |||
} else { | |||
// TOR, aber nicht bester MW -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 0); | |||
} | |||
} | |||
} | |||
// Verbleibende MW anzeigen | |||
if (this.mwE) { | |||
for (let i = this.anzOptiE + 1; i <= this.anzMwE; i++) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue("TOR", __TIME.end), getColor("TOR"), 0); | |||
} else { | |||
// TOR, aber nicht bester MW -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 0); | |||
} | |||
} | |||
} | |||
} else if (this.mwE) { | |||
// Opti soll nicht angezeigt werden, dafuer aber MW | |||
for (let i = 1; i <= this.anzMwE; i++) { | |||
if (player.isGoalie) { | |||
if (i === 1) { | |||
// TOR-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue("TOR", __TIME.end), getColor("TOR"), 0); | |||
} else { | |||
// TOR, aber nicht bester MW -> nur Zelle hinzufuegen | |||
this.addCell(playerRow); | |||
} | |||
} else { | |||
// Feld-MW anzeigen | |||
this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 0); | |||
} | |||
} | |||
} | |||
}; // Ende addValues(player, playerRow) | |||
} | |||
// | // Klasse PlayerRecord ****************************************************************** | ||
function PlayerRecord(age, skills, isGoalie) { | |||
const | // Zu benutzende Marktwertformel | ||
const __MWFORMEL = { | |||
'alt' : 0, // Marktwertformel bis Saison 9 inklusive | |||
'S10' : 1 // Marktwertformel MW5 ab Saison 10 | |||
}; | |||
// | this.mwFormel = __MWFORMEL.S10; // Neue Formel, genauer in initPlayer() | ||
this.age = age; | |||
this.skills = skills; | |||
this.isGoalie = isGoalie; | |||
// in this.initPlayer() definiert: | |||
// this.zatGeb: ZAT, an dem der Spieler Geburtstag hat, -1 fuer "noch nicht zugewiesen", also '?' | |||
// this.zatAge: Bisherige erfolgte Trainings-ZATs | |||
// this.talent: Talent als Zahl (-1=wenig, 0=normal, +1=hoch) | |||
// this.aufwert: Aufwertungsstring | |||
// this.mwFormel: Benutzte MW-Formel, siehe __MWFORMEL | |||
// this.positions[][]: Positionstext und Opti; TOR-Index ist 5 | |||
// this.skillsEnd[]: Berechnet aus this.skills, this.age und aktuellerZat | |||
this.toString = function() { | |||
let result = "Alter\t\t" + this.age + "\n\n"; | |||
result += "Aktuelle Werte\n"; | |||
result += "Skillschnitt\t" + this.getSkill().toFixed(2) + '\n'; | |||
result += "Optis und Marktwerte"; | |||
for (let pos of this.positions) { | |||
result += "\n\t" + pos + '\t'; | |||
result += this.getOpti(pos).toFixed(2) + '\t'; | |||
result += getNumberString(this.getMarketValue(pos).toString()); | |||
} | |||
result += "\n\nWerte mit Ende 18\n"; | |||
result += "Skillschnitt\t" + this.getSkill(__TIME.end).toFixed(2) + '\n'; | |||
result += "Optis und Marktwerte"; | |||
for (let pos of this.positions) { | |||
result += "\n\t" + this.getPos()[i] + '\t'; | |||
result += this.getOpti(pos, __TIME.end).toFixed(2) + '\t'; | |||
result += getNumberString(this.getMarketValue(pos, __TIME.end).toString()); | |||
} | |||
} | |||
// | return result; | ||
}; // Ende this.toString() | |||
// | // Berechnet die Opti-Werte, sortiert das Positionsfeld und berechnet die Einzelskills mit Ende 18 | ||
function | this.initPlayer = function(saison, currZAT, gebZAT, tclass, progresses) { | ||
this.zatGeb = gebZAT; | |||
this.zatAge = this.calcZatAge(currZAT); | |||
this.talent = tclass; | |||
this.aufwert = progresses; | |||
this.mwFormel = (saison < 10) ? __MWFORMEL.alt : __MWFORMEL.S10; | |||
this.positions = []; | |||
// ABW | |||
this.positions[0] = []; | |||
this.positions[0][0] = "ABW"; | |||
this.positions[0][1] = this.getOpti("ABW"); | |||
// DMI | |||
this.positions[1] = []; | |||
this.positions[1][0] = "DMI"; | |||
this.positions[1][1] = this.getOpti("DMI"); | |||
// MIT | |||
this.positions[2] = []; | |||
this.positions[2][0] = "MIT"; | |||
this.positions[2][1] = this.getOpti("MIT"); | |||
// OMI | |||
this.positions[3] = []; | |||
this.positions[3][0] = "OMI"; | |||
this.positions[3][1] = this.getOpti("OMI"); | |||
// STU | |||
this.positions[4] = []; | |||
this.positions[4][0] = "STU"; | |||
this.positions[4][1] = this.getOpti("STU"); | |||
// TOR | |||
this.positions[5] = []; | |||
this.positions[5][0] = "TOR"; | |||
this.positions[5][1] = this.getOpti("TOR"); | |||
// Sortieren | |||
sortPositionArray(this.positions); | |||
// Einzelskills mit Ende 18 berechnen | |||
this.skillsEnd = []; | |||
/ | const __ADDRATIO = (this.getZatAge(__TIME.end) - this.getZatAge()) / this.getZatAge(); | ||
for (let i in this.skills) { | |||
const __SKILL = this.skills[i]; | |||
let progSkill = __SKILL; | |||
if (isTrainableSkill(i)) { | |||
// Auf ganze Zahl runden und parseInt(), da das sonst irgendwie als String interpretiert wird | |||
const __ADDSKILL = parseInt((__ADDRATIO * __SKILL).toFixed(0), 10); | |||
progSkill += __ADDSKILL; | |||
} | |||
} | |||
this.skillsEnd[i] = Math.min(progSkill, 99); | |||
} | |||
}; // Ende this.initPlayer() | |||
this.getGeb = function() { | |||
return (this.zatGeb < 0) ? '?' : this.zatGeb; | |||
}; | |||
this.calcZatAge = function(currZAT) { | |||
if (this.age < 13) { | |||
return 0; // noch nicht trainiert | |||
} else { | |||
let ZATs = (this.age - ((currZAT < this.zatGeb) ? 12 : 13)) * 72; // Basiszeit fuer die Jahre seit Jahrgang 13 | |||
if (this.zatGeb < 0) { | |||
return ZATs + currZAT; // Zaehlung begann Anfang der Saison (und der Geburtstag wird erst nach dem Ziehen bestimmt) | |||
} else { | |||
return ZATs + currZAT - this.zatGeb; // Verschiebung relativ zum Geburtstag (von -zatGeb, ..., 0, ..., 71 - zatGeb) | |||
// | |||
} | } | ||
} | } | ||
} | }; | ||
// | this.getZatAge = function(when = __TIME.now) { | ||
if (when === __TIME.end) { | |||
function | return (18 - 12) * 72 - 1; // (max.) Trainings-ZATs bis Ende 18 | ||
} else { | |||
return this.zatAge; | |||
} | |||
}; | |||
this.getAge = function(when = __TIME.now) { | |||
if (this.mwFormel === __MWFORMEL.alt) { | |||
return (when === __TIME.end) ? 18 : this.age; | |||
} else { // Geburtstage ab Saison 10... | |||
return (13.00 + this.getZatAge(when) / 72); | |||
} | |||
}; | |||
this. | this.getTrainierteSkills = function() { | ||
let sum = 0; | |||
for (let i in this.skills) { | |||
if (isTrainableSkill(i)) { | |||
sum += this.skills[i]; | |||
} | |||
} | |||
return | return sum; | ||
}; | }; | ||
this. | this.getAufwertungsSchnitt = function() { | ||
return parseFloat(this.getTrainierteSkills() / this.getZatAge()); | |||
}; | }; | ||
this. | this.getPos = function(idx) { | ||
const __IDXOFFSET = 1; | |||
return this.positions[idx - __IDXOFFSET][0]; | |||
}; | |||
this.getTalent = function() { | |||
return (this.talent < 0) ? "wenig" : (this.talent > 0) ? "hoch" : "normal"; | |||
}; | |||
this.getAufwert = function() { | |||
return (this.aufwert.length > 0) ? this.aufwert : "keine"; | |||
}; | }; | ||
this. | this.getSkill = function(when = __TIME.now) { | ||
const __SKILLS = (when === __TIME.end) ? this.skillsEnd : this.skills; | |||
let result = 0; | |||
for (let skill of __SKILLS) { | |||
result += skill; | |||
} | } | ||
return result / __SKILLS.length; | |||
}; | |||
this.getOpti = function(pos, when = __TIME.now) { | |||
const __SKILLS = (when === __TIME.end) ? this.skillsEnd : this.skills; | |||
const __IDXPRISKILLS = getIdxPriSkills(pos); | |||
const __IDXSECSKILLS = getIdxSecSkills(pos); | |||
let sumPriSkills = 0; | |||
let sumSecSkills = 0; | |||
for (let idx of __IDXPRISKILLS) { | |||
sumPriSkills += __SKILLS[idx]; | |||
} | } | ||
for (let idx of __IDXSECSKILLS) { | |||
sumSecSkills += __SKILLS[idx]; | |||
} | } | ||
return (5 * sumPriSkills + sumSecSkills) / 27; | |||
}; | |||
this.getMarketValue = function(pos, when = __TIME.now) { | |||
const __AGE = this.getAge(when); | |||
if (this. | |||
this. | if (this.mwFormel === __MWFORMEL.alt) { | ||
return Math.round(Math.pow((1 + this.getSkill(when)/100) * (1 + this.getOpti(pos, when)/100) * (2 - __AGE/100), 10) * 2); // Alte Formel bis Saison 9 | |||
} else { // MW-Formel ab Saison 10... | |||
const __MW5TF = 1.00; // Zwischen 0.97 und 1.03 | |||
} | |||
return Math.round(Math.pow(1 + this.getSkill(when)/100, 5.65) * Math.pow(1 + this.getOpti(pos, when)/100, 8.1) * Math.pow(1 + (100 - __AGE)/49, 10) * __MW5TF); | |||
} | } | ||
}; | |||
} | |||
// Funktionen fuer die HTML-Seite ******************************************************* | |||
// Liest das Alter aus | |||
// return Alter als Zahl | |||
function getAgeFromHTML(cells, colIdxAge) { | |||
return parseInt(cells[colIdxAge].textContent, 10); | |||
} | |||
// Liest das Geburtsdatum aus | |||
// return Geburtsdatum als ZAT | |||
function getGebFromHTML(cells, colIdxGeb) { | |||
const __TEXT = ((cells[colIdxGeb] === undefined) ? '?' : cells[colIdxGeb].textContent); | |||
return parseInt((__TEXT === '?') ? -1 : __TEXT, 10); | |||
} | |||
// Liest die Talentklasse ("wenig", "normal", "hoch") aus | |||
// return Talent als Zahl (-1=wenig, 0=normal, +1=hoch) | |||
function getTalentFromHTML(cells, colIdxTal) { | |||
const __TEXT = ((cells[colIdxTal] === undefined) ? '?' : cells[colIdxTal].textContent); | |||
return parseInt((__TEXT === "wenig") ? -1 : (__TEXT === "hoch") ? +1 : 0, 10); | |||
} | } | ||
// | // Liest die Aufwertungen aus | ||
// return Aufwertungen als String | |||
function getAufwertFromHTML(cells, colIdxAuf) { | |||
const __TEXT = ((cells[colIdxAuf] === undefined) ? '?' : cells[colIdxAuf].textContent); | |||
return __TEXT.toString(); | |||
} | |||
// Liest die Einzelskills aus | |||
// return Skills als Array von Zahlen | |||
function getSkillsFromHTML(cells, colIdx) { | |||
const __RESULT = []; | |||
for (let i = colIdx.Einz; i < colIdx.Zus; i++) { | |||
__RESULT[i - colIdx.Einz] = parseInt(cells[i].textContent, 10); | |||
} | |||
return __RESULT; | |||
} | |||
// Liest aus, ob der Spieler Torwart oder Feldspieler ist | |||
// return Angabe, der Spieler Torwart oder Feldspieler ist | |||
function isGoalieFromHTML(cells, colIdxClass) { | |||
return (cells[colIdxClass].className === "TOR"); | |||
} | |||
// Hilfsfunktionen ********************************************************************** | |||
// Sortiert das Positionsfeld per BubbleSort | |||
function sortPositionArray(array) { | |||
const __TEMP = []; | |||
let transposed = true; | |||
// TOR soll immer die letzte Position im Feld sein, deshalb - 1 | |||
let length = array.length - 1; | |||
while (transposed && (length > 1)) { | |||
transposed = false; | |||
for (let i = 0; i < length - 1; i++) { | |||
// Vergleich Opti-Werte: | |||
for (let | if (array[i][1] < array[i + 1][1]) { | ||
// vertauschen | |||
__TEMP[0] = array[i][0]; | |||
__TEMP[1] = array[i][1]; | |||
array[i][0] = array[i + 1][0]; | |||
array[i][1] = array[i + 1][1]; | |||
array[i + 1][0] = __TEMP[0]; | |||
array[i + 1][1] = __TEMP[1]; | |||
transposed = true; | |||
} | |||
} | } | ||
length--; | |||
} | |||
} | |||
// Fuegt in die uebergebene Zahl Tausender-Trennpunkte ein | |||
// Wandelt einen etwaig vorhandenen Dezimalpunkt in ein Komma um | |||
function getNumberString(numberString) { | |||
if (numberString.lastIndexOf(".") !== -1) { | |||
// Zahl enthaelt Dezimalpunkt | |||
const __VORKOMMA = numberString.substring(0, numberString.lastIndexOf(".")); | |||
const __NACHKOMMA = numberString.substring(numberString.lastIndexOf(".") + 1, numberString.length); | |||
// | return getNumberString(__VORKOMMA) + "," + __NACHKOMMA; | ||
} else { | |||
// Kein Dezimalpunkt, fuege Tausender-Trennpunkte ein: | |||
// String umdrehen, nach jedem dritten Zeichen Punkt einfuegen, dann wieder umdrehen: | |||
const __TEMP = reverseString(numberString); | |||
let result = ""; | |||
for (let i = 0; i < __TEMP.length; i++) { | |||
if ((i > 0) && (i % 3 === 0)) { | |||
result += "."; | |||
} | |||
result += __TEMP.substr(i, 1); | |||
} | |||
return reverseString(result); | |||
} | |||
} | |||
// Dreht den uebergebenen String um | |||
function reverseString(string) { | |||
let result = ""; | |||
for (let i = string.length - 1; i >= 0; i--) { | |||
result += string.substr(i, 1); | |||
} | |||
return result; | |||
} | |||
// Schaut nach, ob der uebergebene Index zu einem trainierbaren Skill gehoert | |||
// Die Indizes gehen von 0 (SCH) bis 16 (EIN) | |||
function isTrainableSkill(idx) { | |||
const __TRAINABLESKILLS = [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 15]; | |||
const __IDX = parseInt(idx, 10); | |||
let result = false; | |||
for (let idxTrainable of __TRAINABLESKILLS) { | |||
if (__IDX === idxTrainable) { | |||
result = true; | |||
break; | |||
} | } | ||
} | } | ||
return result; | |||
} | |||
// Gibt die Indizes der Primaerskills zurueck | |||
function getIdxPriSkills(pos) { | |||
switch (pos) { | |||
case "TOR" : return new Array(2, 3, 4, 5); | |||
case "ABW" : return new Array(2, 3, 4, 15); | |||
case "DMI" : return new Array(1, 4, 9, 11); | |||
return | case "MIT" : return new Array(1, 3, 9, 11); | ||
case "OMI" : return new Array(1, 5, 9, 11); | |||
case "STU" : return new Array(0, 2, 3, 5); | |||
default : return []; | |||
} | |||
} | |||
return ( | |||
} | |||
// Gibt die Indizes der Sekundaerskills zurueck | |||
function getIdxSecSkills(pos) { | |||
switch (pos) { | |||
case "TOR" : return new Array(0, 1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); | |||
case "ABW" : return new Array(0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16); | |||
case "DMI" : return new Array(0, 2, 3, 5, 6, 7, 8, 10, 12, 13, 14, 15, 16); | |||
case "MIT" : return new Array(0, 2, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 16); | |||
case "OMI" : return new Array(0, 2, 3, 4, 6, 7, 8, 10, 12, 13, 14, 15, 16); | |||
case "STU" : return new Array(1, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16); | |||
default : return []; | |||
return | |||
} | } | ||
} | |||
// Gibt die zur Position gehoerige Farbe zurueck | |||
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 ""; | |||
} | |||
} | |||
// ==================== Ende Abschnitt genereller Code zur Anzeige der Jugend ==================== | |||
// ==================== Abschnitt fuer sonstige Parameter ==================== | |||
const __TEAMSEARCHHAUPT = { // Parameter zum Team "<b>Willkommen im Managerbüro von TEAM</b><br>LIGA LAND<a href=..." | |||
'Zeile' : 0, | |||
'Spalte' : 1, | |||
'start' : " von ", | |||
'middle' : "</b><br>", | |||
'liga' : ". Liga", | |||
'land' : ' ', | |||
'end' : "<a href=" | |||
}; | }; | ||
const __TEAMSEARCHTEAM = { // Parameter zum Team "<b>TEAM - LIGA <a href=...>LAND</a></b>" | |||
'Zeile' : 0, | |||
'Spalte' : 0, | |||
'start' : "<b>", | |||
'middle' : " - ", | |||
'liga' : ". Liga", | |||
'land' : 'target="_blank">', | |||
'end' : "</a></b>" | |||
}; | }; | ||
// Ermittelt, wie das eigene Team heisst und aus welchem Land bzw. Liga es kommt (zur Unterscheidung von Erst- und Zweitteam) | |||
// cell: Tabellenzelle mit den Parametern zum Team "startTEAMmiddleLIGA...landLANDend", LIGA = "#liga[ (A|B|C|D)]" | |||
// teamSeach: Muster fuer die Suche, die Eintraege fuer 'start', 'middle', 'liga', 'land' und 'end' enthaelt | |||
// return Im Beispiel { 'Team' : "TEAM", 'Liga' : "LIGA", 'Land' : "LAND", 'LdNr' : LAND-NUMMER, 'LgNr' : LIGA-NUMMER }, | |||
// z.B. { 'Team' : "Choromonets Odessa", 'Liga' : "1. Liga", 'Land' : "Ukraine", 'LdNr' : 20, 'LgNr' : 1 } | |||
function getTeamParamsFromTable(table, teamSearch = undefined) { | |||
const __TEAMSEARCH = getValue(teamSearch, __TEAMSEARCHHAUPT); | |||
const __TEAMCELLROW = getValue(__TEAMSEARCH.Zeile, 0); | |||
const __TEAMCELLCOL = getValue(__TEAMSEARCH.Spalte, 0); | |||
const __TEAMCELLSTR = table.rows[__TEAMCELLROW].cells[__TEAMCELLCOL].innerHTML; | |||
const __SEARCHSTART = __TEAMSEARCH.start; | |||
const __SEARCHMIDDLE = __TEAMSEARCH.middle; | |||
const __SEARCHLIGA = __TEAMSEARCH.liga; | |||
const __SEARCHLAND = __TEAMSEARCH.land; | |||
const __SEARCHEND = __TEAMSEARCH.end; | |||
const __INDEXSTART = __TEAMCELLSTR.indexOf(__SEARCHSTART); | |||
const __INDEXEND = __TEAMCELLSTR.indexOf(__SEARCHEND); | |||
let teamParams = __TEAMCELLSTR.substring(__INDEXSTART + __SEARCHSTART.length, __INDEXEND); | |||
const __INDEXLIGA = teamParams.indexOf(__SEARCHLIGA); | |||
const __INDEXMIDDLE = teamParams.indexOf(__SEARCHMIDDLE); | |||
let land = (__INDEXLIGA > 0) ? teamParams.substring(__INDEXLIGA + __SEARCHLIGA.length) : undefined; | |||
const __TEAM = (__INDEXMIDDLE > 0) ? teamParams.substring(0, __INDEXMIDDLE) : undefined; | |||
let liga = ((__INDEXLIGA > 0) && (__INDEXMIDDLE > 0)) ? teamParams.substring(__INDEXMIDDLE + __SEARCHMIDDLE.length) : undefined; | |||
if (land !== undefined) { | |||
if (land.charAt(2) === ' ') { // Land z.B. hinter "2. Liga A " statt "1. Liga " | |||
land = land.substr(2); | |||
} | } | ||
if (liga !== undefined) { | |||
liga = liga.substring(0, liga.length - land.length); | |||
} | } | ||
const __INDEXLAND = land.indexOf(__SEARCHLAND); | |||
if (__INDEXLAND > -1) { | |||
land = land.substr(__INDEXLAND + __SEARCHLAND.length); | |||
} | } | ||
} | |||
const __RET = { | |||
'Team' : __TEAM, | |||
'Liga' : liga, | |||
'Land' : land, | |||
'LdNr' : getLandNr(land), | |||
'LgNr' : getLigaNr(liga) | |||
}; | }; | ||
return __RET; | |||
} | |||
// Verarbeitet die URL der Seite und ermittelt die Nummer der gewuenschten Unterseite | |||
// url: Adresse der Seite | |||
// return Parameter aus der URL der Seite als Nummer | |||
function getPageIdFromURL(url) { | |||
// Variablen zur Identifikation der Seite | |||
const __SUCH = "page="; | |||
const __INDEXS = url.lastIndexOf(__SUCH); | |||
const __HAUPT = url.match(/haupt\.php/); // Ansicht "Haupt" (Managerbuero) | |||
const __JU = url.match(/ju\.php/); // Ansicht "Jugendteam" | |||
let page = -1; // Seitenindex (Rueckgabewert) | |||
// Wert von page (Seitenindex) ermitteln... | |||
// Annahme: Entscheidend ist jeweils das letzte Vorkommnis von "page=" und ggf. von '&' | |||
if (__HAUPT) { | |||
page = 0; | |||
} else if (__JU) { | |||
if (__INDEXS < 0) { | |||
page = 1; | |||
} else if (url.indexOf('&', __INDEXS) < 0) { | |||
// Wert von page setzt sich aus allen Zeichen hinter "page=" zusammen | |||
page = parseInt(url.substring(__INDEXS + __SUCH.length, url.length), 10); | |||
} else { | |||
// Wert von page setzt sich aus allen Zeichen zwischen "page=" und '&' zusammen | |||
page = parseInt(url.substring(__INDEXS + __SUCH.length, url.indexOf('&', __INDEXS)), 10); | |||
} | } | ||
}; | } | ||
return page; | |||
} | } | ||
// | // Gibt die laufende Nummer des ZATs im Text einer Zelle zurueck | ||
// cell: Tabellenzelle mit der ZAT-Nummer im Text | |||
// return ZAT-Nummer im Text | |||
function getZATNrFromCell(cell) { | |||
const __TEXT = cell.textContent.split(' '); | |||
let ZATNr = 0; | |||
for (let i = 1; (ZATNr === 0) && (i < __TEXT.length); i++) { | |||
if (__TEXT[i - 1] === "ZAT") { | |||
if (__TEXT[i] !== "ist") { | |||
ZATNr = parseInt(__TEXT[i], 10); | |||
} | } | ||
} | } | ||
} | } | ||
return | return ZATNr; | ||
} | } | ||
// | // ==================== Ende Abschnitt fuer sonstige Parameter ==================== | ||
// ==================== Hauptprogramm ==================== | |||
// Verarbeitet Ansicht "Haupt" (Managerbuero) zur Ermittlung des aktuellen ZATs | |||
function procHaupt() { | |||
const __TEAMPARAMS = getTeamParamsFromCell(getTable(1), __TEAMSEARCHHAUPT); // Link mit Team, Liga, Land... | |||
buildOptions(__OPTCONFIG, __OPTSET, { | |||
'teamParams' : __TEAMPARAMS, | |||
'hideMenu' : true | |||
}); | |||
const __NEXTZAT = getZATNrFromCell(getRows(0)[2].cells[0]); // "Der naechste ZAT ist ZAT xx und ..." | |||
const __CURRZAT = __NEXTZAT - 1; | |||
if (__CURRZAT >= 0) { | |||
console.log("Aktueller ZAT: " + __CURRZAT); | |||
setOpt(__OPTSET.aktuellerZat, __CURRZAT, false); | |||
} | |||
} | } | ||
// | // Verarbeitet Ansicht "Teamuebersicht" | ||
function procTeamuebersicht() { | |||
const __ROWOFFSETUPPER = 1; // Header-Zeile | |||
const __ROWOFFSETLOWER = 1; // Ziehen-Button | |||
// | |||
const | |||
const __COLUMNINDEX = { | |||
'Age' : 0, | |||
} | 'Geb' : 1, | ||
'Flg' : 2, | |||
'Land' : 3, | |||
'U' : 4, | |||
'Skill' : 5, | |||
'Tal' : 6, | |||
'Akt' : 7, | |||
'Auf' : 8, | |||
'Zus' : 9 | |||
}; | |||
const __BIRTHDAYS = []; | |||
const __TCLASSES = []; | |||
const __PROGRESSES = []; | |||
if (getRows(1) === undefined) { | |||
console.log("Diese Seite ist ohne Team nicht verf\xFCgbar!"); | |||
} else if (getTable(1).length < 3) { | |||
console.log("Ziehen-Seite"); | |||
} | } else { | ||
buildOptions(__OPTCONFIG, __OPTSET, { | |||
'menuAnchor' : getTable(0, "div"), | |||
'showForm' : { | |||
'sepStyle' : true, | |||
'sepColor' : true, | |||
'sepWidth' : true, | |||
'aktuellerZat' : true, | |||
'team' : true, | |||
'reset' : true, | |||
'showForm' : true | |||
}, | |||
'formWidth' : 1 | |||
}); | |||
const __ROWS = getRows(1); | |||
const | |||
for (let i = __ROWOFFSETUPPER; i < __ROWS.length - __ROWOFFSETLOWER; i++) { | |||
__BIRTHDAYS[i - __ROWOFFSETUPPER] = getGebFromHTML(__ROWS[i].cells, __COLUMNINDEX.Geb); | |||
__TCLASSES[i - __ROWOFFSETUPPER] = getTalentFromHTML(__ROWS[i].cells, __COLUMNINDEX.Tal); | |||
__PROGRESSES[i - __ROWOFFSETUPPER] = getAufwertFromHTML(__ROWS[i].cells, __COLUMNINDEX.Auf); | |||
} | } | ||
setOpt(__OPTSET.birthdays, __BIRTHDAYS, false); | |||
setOpt(__OPTSET.tclasses, __TCLASSES, false); | |||
setOpt(__OPTSET.progresses, __PROGRESSES, false); | |||
// Format der Trennlinie zwischen den Monaten... | // Format der Trennlinie zwischen den Monaten... | ||
| Zeile 2.903: | Zeile 2.484: | ||
buildOptions(__OPTCONFIG, __OPTSET, { | buildOptions(__OPTCONFIG, __OPTSET, { | ||
'menuAnchor' : getTable(0, "div"), | 'menuAnchor' : getTable(0, "div"), | ||
'formWidth' : 1 | 'formWidth' : 1 | ||
}); | }); | ||
| Zeile 2.918: | Zeile 2.494: | ||
__COLMAN.addTitles(__HEADERS, __TITLECOLOR); | __COLMAN.addTitles(__HEADERS, __TITLECOLOR); | ||
const __PLAYERS = init(__ROWS, __OPTSET, __COLUMNINDEX, __ROWOFFSETUPPER, __ROWOFFSETLOWER | const __PLAYERS = init(__ROWS, __OPTSET, __COLUMNINDEX, __ROWOFFSETUPPER, __ROWOFFSETLOWER); | ||
for (let i = 0; i < __PLAYERS.length; i++) { | for (let i = 0; i < __PLAYERS.length; i++) { | ||